Objetivo: escribir un programa o función que imprima una cadena de entrada en forma sinusoidal.

La sinusoide ASCII

Aquí hay un período de la sinusoide:

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

Tenga en cuenta que hay exactamente un punto en cada columna.

• Cada carácter en la cadena de entrada reemplazará un punto en la forma anterior, de izquierda a derecha.
• Los espacios en la entrada deben emitirse como caracteres normales, en lugar de un punto.
• El carácter inicial corresponde al punto más a la izquierda en la figura de arriba.
• Este es solo un período, las entradas pueden ser más largas que la cantidad de puntos anteriores.

Entrada

• Las entradas son cadenas ASCII que contienen solo caracteres entre ASCII decimal 32 (espacio) y ASCII decimal 126 (Tilde ~).
• Las entradas siempre serán de una sola línea (sin saltos de línea).
• Las entradas se pueden tomar a través de STDIN, parámetros de función, argumentos de línea de comando o cualquier cosa similar.

Salida

• La salida debe imprimirse exactamente como en los casos de prueba indicados.
• Los espacios finales en las líneas están permitidos siempre que la longitud de la línea con esos espacios finales no exceda la longitud de la línea más larga (la que tiene el último carácter).
• No se permiten líneas iniciales / finales.

Casos de prueba

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

Salida:

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

• 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.

Salida:

         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.

Salida:

         t.
      tex  
    t      
   r       
  o        
 h         
S          

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

Salida:

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

                          o                
                           v               
                            er             
                               th       dog
                                 e lazy    

Tanteo

Este es el código de golf , por lo que gana el programa o la función más corta en bytes.

Pyth, 59 bytes (57 caracteres)

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

Demostración.

Una tabla de búsqueda binaria está codificada en su interior ཈, que tiene el valor 3912. Esto se convierte en binario, dando [1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0]. Esto se trata como las diferencias entre las alturas consecutivas. Al anteponer un 6, formando todos los prefijos y asignando cada uno a su suma, se genera el primer cuarto de la onda.

sM._+6jC\཈2evalúa [6, 7, 8, 9, 10, 10, 11, 11, 11, 12, 12, 12, 12]como se describe anteriormente. Luego, el código se concatena en el reverso de esta cadena para formar la primera mitad de la onda, y luego la resta de 12 para dar la onda completa.

Luego, formamos líneas de cada carácter de entrada seguido de 12 espacios. Esta línea se gira hacia la derecha por el parámetro de altura de onda correspondiente a esa ubicación, y luego las líneas se transponen y se unen en nuevas líneas.

Luego, eliminamos las líneas en blanco iniciales y finales. Sin embargo, no podemos quitar las líneas en blanco iniciales o finales que tienen espacios desde la entrada. Esto se implementa reemplazando espacios en la entrada con pestañas ( C9), que no pueden estar en la entrada, quitando líneas en blanco y volviendo las pestañas a espacios.

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]

Explicación

• Todo el código simplemente crea un bloque de espacios ( o) y reemplaza los espacios correctos con las letras de la entrada t.

• La variable lalmacena una lista de desplazamientos desde la parte superior. Para que el ncarácter de th testé en línea l[n].

• El bytearray osirve como una cadena mutable, ya que las cadenas son inmutables en python.

• -~hes lo mismo h+1pero ahorra espacio porque no necesito paréntesis.

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);}

Todavía soy un novato aquí, y espero que cumpla con las reglas para introducir una subfunción (cuando los bytes de esta función se cuentan, por supuesto). Si no, intentaré convertir la sinfunción en una búsqueda inteligente de arreglos ...

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

Requiere -Epara say, almacena las posiciones como números enteros convertidos en números binarios y el volteo de la matriz probablemente no sea muy eficiente en bytes. También estoy seguro de que hay muchos ahorros que hacer, así que seguiré hurgando y empujando.

Salida de ejemplo:

$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

Implementación realmente simple: utiliza una cadena de caracteres para representar la posición y de cada carácter en la onda (compensado por a, que es el código ASCII 97). Luego itera a través de todas las filas posibles; Si el valor y de la fila actual es el mismo que la posición y en la onda, escribe un carácter de la cadena. También hay una limpieza al final para eliminar la fila si resultó estar completamente en blanco.

Tenga en cuenta que la salida aparecerá inestable en la alert()ventana si no está usando una fuente monoespaciada, puede cambiarla console.log()para verificar que la salida sea correcta.

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"))

EDITAR1: ++y --existir.

EDIT2: la eliminación de la línea en blanco ahora se realiza en el mismo bucle que el resto, ahorrando 17 caracteres. Tampoco necesitaba esos corchetes, para 2 caracteres adicionales.

EDITAR3: No es necesario declarar la forma de onda como variable, ahorrando 4 caracteres.

EDITAR4: Como lo señaló Dom Hastings en los comentarios, el recuento de bytes incluyó el retorno de carro, así como el carácter de nueva línea, actualizó los recuentos de bytes para todas las revisiones para excluir el retorno de carro.

EDIT5: Guardado 3 bytes por cortesía de Dom Hastings. No he implementado la o.splicecorrección ya que esto no puede eliminar las líneas en blanco (al menos en mi extremo).

Matlab, 133 , 130 bytes

El único revestimiento:

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

Y la versión ampliada:

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

El one liner toma entrada de la consola ( stdin) y tiene 130 bytes. La versión ampliada reemplaza la entrada de la consola por una definición de función (+1 byte) pero es mucho más cómoda de usar para el caso de prueba en un bucle:

Descripción:

El índice de línea de cada carácter se calcula para un período medio, luego se refleja y concatena para tener un período completo.
Creamos un fondo en blanco de carácter de espacio en blanco (la misma longitud que la cadena de entrada. Colocamos cada carácter de acuerdo con su posición en la línea correspondiente. Si la cadena de entrada es más larga que un punto, el modoperador (módulo) lo ajusta así que no lo hacemos ' No salga del límite cuando solicite el número de línea.

Caso de prueba:

Guarde la versión de la función textsine.men su ruta, luego ejecute:

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

dará salida:

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    

Si desea probar la versión de un trazador de líneas con la entrada de stdin, su entrada debe ingresarse como una sola string, por lo que tendría que encerrar su entrada entre los 'caracteres. Ejemplo:

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

_{Gracias Luis Mendopor recortar 3 bytes ;-)}

Scala 377 caracteres

primer corte. Probablemente puede obtener una mejor fórmula para traducir xay

(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 común, 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))))

Pruebas

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

Observaciones

Imprima la salida línea por línea, calculando los índices en las cadenas que deben imprimirse utilizando la función seno inversa asin. La salida no coincide exactamente con las entradas esperadas en la pregunta, pero dado que OP reconoce que las salidas de ejemplo no son senoidal real, supongo que esto está bien. Al menos, siempre hay un solo carácter escrito para cada columna.

Python 2, 172 bytes

Esto no es tan bueno como la respuesta de Alex L , pero está bastante cerca. Toma información de entrada estándar y funciona mejor en un .pyarchivo.

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])

Decidí construir la salida transpuesta (cada columna es una fila) y luego transponer el resultado, ya que en Python la transposición de una matriz es map(*m).

• l: La representación binaria de 9960000(después de cortar el "0b"from bin) es 100101111111101001000000. Este es el "paso" de la onda sinusoidal de cada columna, comenzando en el último carácter del punto más bajo. Copio esta lista, niego cada número y lo pego al final de sí mismo para formar lo que efectivamente es una derivada de la función.
• s: Esta es la variable que realiza un seguimiento de en qué fila (columna en la transposición) se inserta el siguiente carácter.
• o: Salida final, transpuesta
• i: Realiza un seguimiento del período de onda sinusoidal. Comienza a las 9 ya que lse desplaza ligeramente.

En el forciclo, creo una lista de 13 espacios (estaba usando bytearrays pero las listas de caracteres tienen una declaración de impresión más corta), luego reemplazo el scarácter th con el carácter de entrada. Agregue bal final de o, agregue el paso apropiado se incremente i.

Esperaba que la printdeclaración fuera tan simple como \n'.join(*zip(o)), pero no tuve tanta suerte. zip(*o+['\n'*13])[::-1]agrega una columna de líneas nuevas y luego invierte y transpone todo (sin la inversión, la onda sinusoidal está al revés), sum(...,())concatena las tuplas juntas en una tupla de caracteres, y luego ''.join(...)concatena los caracteres e imprime.

Otras cosas que intenté fue hacer una matriz de 12 caracteres de espacios e insertar el nuevo personaje en el lugar apropiado, y reemplazarlo l+=[-c for c in l];con algún tipo de matemática con algún tipo de multiplicación 1y -1con el resultado de la indexación l, pero nada de lo que se me ocurrió con terminó siendo más corto.

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"]

Son 131 caracteres, incluidos los tres para i=foo;. Esa parecía una forma razonable de tomar la entrada; Podría haberlo explicado directamente cy haber guardado algunos golpes, pero eso se siente injusto.

Es bastante sencillo, casi incluso legible. Divide la cadena en una lista de caracteres, y luego coloca esos caracteres en una matriz dispersa en las posiciones determinadas desde Table(cualquier punto en la matriz que no tenga un carácter predeterminado es un espacio). Las líneas se ensamblan por separado, luego se salpican líneas nuevas entre ellas. El StringJoin final lo cose todo.

NB: Al igual que algunas otras soluciones, esto puede no ser válido porque produce una sinusoide real en lugar del ejemplo artesanal (hermoso).

Pruebas:

(*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