Obiettivo: scrivere un programma o una funzione che stampa una stringa di input in una forma sinusoidale.

La sinusoide ASCII

Ecco un periodo della sinusoide:

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

Si noti che esiste esattamente un punto su ogni colonna.

• Ogni carattere nella stringa di input sostituirà un punto nella forma sopra, da sinistra a destra.
• Gli spazi nell'input devono essere emessi come caratteri normali, al posto di un punto.
• Il carattere iniziale corrisponde al punto più a sinistra nella figura sopra.
• Questo è solo un periodo, gli input possono essere più lunghi del numero di punti sopra.

Ingresso

• Gli input sono stringhe ASCII che contengono solo caratteri tra i decimali ASCII 32 (spazio) e i decimali ASCII 126 (Tilde ~).
• Gli input saranno sempre solo una riga (nessuna interruzione di riga).
• Gli input possono essere acquisiti tramite STDIN, parametri di funzione, argomenti della riga di comando o simili.

Produzione

• L'output deve essere stampato esattamente come nei casi di test forniti.
• Gli spazi finali su linee sono consentiti purché la lunghezza della linea con quegli spazi finali non superi la lunghezza della linea più lunga (quella con l'ultimo carattere su di essa).
• Nessuna linea principale / finale consentita.

Casi test

• Ingresso: .................................................

Produzione:

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

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

Produzione:

         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                                   

• Ingresso: Short text.

Produzione:

         t.
      tex  
    t      
   r       
  o        
 h         
S          

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

Produzione:

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

                          o                
                           v               
                            er             
                               th       dog
                                 e lazy    

punteggio

Questo è code-golf , quindi vince il programma o la funzione più breve in byte.

Pyth, 59 byte (57 caratteri)

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

Dimostrazione.

Una tabella di ricerca binaria è codificata all'interno ཈, con valore 3912. Questo viene convertito in binario, dando [1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0]. Questo è trattato come le differenze tra altezze consecutive. Anticipando un 6, formando tutti i prefissi e mappandoli ciascuno alla sua somma, viene generato il primo quarto dell'onda.

sM._+6jC\཈2valuta [6, 7, 8, 9, 10, 10, 11, 11, 11, 12, 12, 12, 12]come descritto sopra. Quindi, il codice si concatena sul retro di questa stringa per formare la prima metà dell'onda, quindi la sottrae da 12 per dare l'intera onda.

Quindi, formiamo linee di ogni carattere di input seguito da 12 spazi. Questa linea viene ruotata a destra dal parametro dell'altezza dell'onda corrispondente a quella posizione, quindi le linee vengono trasposte e unite su nuove linee.

Quindi, eliminiamo le righe vuote iniziali e finali. Tuttavia, non possiamo eliminare le righe vuote iniziali o finali che hanno spazi dall'input. Questo viene implementato sostituendo gli spazi nell'input con tabs ( C9), che non possono essere nell'input, rimuovendo le righe vuote e trasformando le schede in spazi.

Python 2, 156 byte

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]

Spiegazione

• L'intero codice crea semplicemente un blocco di spazi ( o) e sostituisce gli spazi giusti con le lettere dell'input t.

• La variabile lmemorizza un elenco di offset dall'alto. In modo che il nth personaggio di tdovrebbe essere on line l[n].

• Il bytearray ofunge da stringa mutabile, poiché le stringhe sono immutabili in Python.

• -~hè lo stesso h+1ma risparmia spazio perché non ho bisogno di parentesi.

Java, 219 209 199 byte

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

Sono ancora un principiante qui e spero che sia conforme alle regole introdurre una sotto-funzione (quando i byte di questa funzione sono contati, ovviamente). In caso contrario, proverò a convertire la sinfunzione in una ricerca di array intelligente ...

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 byte

$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

Richiede -Eper say, memorizza le posizioni come numeri interi in lega Per numeri binari e il capovolgimento della matrice non è probabilmente molto efficienti byte-saggio. Inoltre sono sicuro che ci sono molti risparmi da fare, quindi continuerò a frugare e pungolare.

Esempio di output:

$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

Implementazione davvero semplice: utilizza una stringa di caratteri per rappresentare la posizione y di ciascun carattere sull'onda (offset di a, che è il codice ASCII 97). Quindi scorre tutte le righe possibili; se il valore y della riga corrente è uguale alla posizione y sull'onda, scrive un carattere dalla stringa. C'è anche una pulizia alla fine per rimuovere la riga se si fosse rivelata completamente vuota.

Si noti che l'output apparirà traballante nella alert()finestra se non utilizza un carattere a spaziatura fissa, è possibile modificarlo console.log()per verificare che l'output sia corretto.

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: ++ed --esiste.

EDIT2: la rimozione delle righe vuote ora viene eseguita nello stesso loop degli altri, salvando 17 caratteri. Non servivano nemmeno quelle parentesi, per altri 2 caratteri.

EDIT3: non è necessario dichiarare la forma d'onda come variabile, salvando 4 caratteri.

EDIT4: Come sottolineato da Dom Hastings nei commenti, il conteggio dei byte includeva il ritorno a capo così come il carattere di nuova riga, ha aggiornato i conteggi dei byte per tutte le revisioni per escludere il ritorno a capo.

EDIT5: 3 byte salvati per gentile concessione di Dom Hastings. Non ho implementato la o.splicecorrezione in quanto ciò non riesce a rimuovere le righe vuote (almeno da parte mia).

Matlab, 133 , 130 byte

L'unica fodera:

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 la versione estesa:

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

L'unico liner prende input dalla console ( stdin) ed è di 130 byte. La versione espansa sostituisce l'input della console con una definizione di funzione (+1 byte) ma è molto più comoda da usare per il test case in un loop:

Descrizione:

L'indice di riga di ciascun carattere viene calcolato per un periodo di metà, quindi specchiato e concatenato per avere un periodo completo.
Creiamo uno sfondo bianco di carattere spazio bianco (stessa lunghezza della stringa di input. Posizioniamo ogni carattere in base alla sua posizione nella riga pertinente. Se la stringa di input è più lunga di un punto, l' modoperatore (modulo) lo avvolge e quindi non t fuori limite quando si richiede il numero di riga.

Caso di prova:

Salvare la versione della funzione textsine.mnel percorso, quindi eseguire:

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

produrrà:

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 si vuole testare la versione uno di linea con il contributo di stdin, l'input deve essere inserito come una sola string, in modo che avrebbe dovuto racchiudere il vostro ingresso tra 'i personaggi. Esempio:

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

_{Grazie Luis Mendoper aver rasato 3 byte ;-)}

Scala 377 caratteri

primo taglio. Probabilmente si potranno ottenere una formula migliore di tradurre 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 comune, 205 byte

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

test

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

Osservazioni

Stampa l'output riga per riga, calcolando gli indici nelle stringhe che devono essere stampate utilizzando la funzione seno inverso asin. L'output non corrisponde esattamente agli input previsti nella domanda, ma poiché OP riconosce che gli output di esempio non sono veri sinusoidi, suppongo che questo sia ok. Almeno, c'è sempre solo un carattere scritto per ogni colonna.

Python 2, 172 byte

Questo non è buono come la risposta di Alex L , ma è abbastanza vicino. Prende l'input dall'input standard e funziona meglio in un .pyfile.

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

Ho deciso di costruire l'output trasposto (ogni colonna è una riga) e quindi trasporre il risultato, poiché in Python lo è la trasposizione di una matrice map(*m).

• l: La rappresentazione binaria di 9960000(dopo aver troncato il "0b"da bin) è 100101111111101001000000. Questo è il "passo" dell'onda sinusoidale di ogni colonna, a partire dall'ultimo carattere del punto più basso. Copio questo elenco, annullo ogni numero e lo applico alla fine di se stesso per formare ciò che è effettivamente un derivato della funzione.
• s: Questa è la variabile che tiene traccia di quale riga (colonna nella trasposizione) viene inserito il carattere successivo.
• o: Uscita finale, trasposta
• i: Tiene traccia del periodo delle onde sinusoidali. Inizia da 9 poiché lè leggermente spostato.

Nel forciclo, creo un elenco di 13 spazi (stavo usando i bytearrays ma gli elenchi di caratteri risultano avere un'istruzione di stampa più breve), quindi sostituisco il scarattere th con il carattere di input. Aggiungi balla fine di o, aggiungi il passaggio appropriato se incrementa i.

Speravo che l' printaffermazione fosse semplice come \n'.join(*zip(o)), ma senza tale fortuna. zip(*o+['\n'*13])[::-1]aggiunge una colonna di nuove righe e quindi inverte e traspone il tutto (senza l'inversione, l'onda sinusoidale è capovolta), sum(...,())concatena le tuple in una tupla di caratteri, quindi ''.join(...)concatena i personaggi e la stampa.

Altre cose che ho provato sono state la creazione di una serie di spazi di 12 caratteri e l'inserimento del nuovo personaggio nel posto appropriato, e la sostituzione l+=[-c for c in l];con una sorta di matematica con una sorta di moltiplicazione 1e -1con il risultato dell'indicizzazione in l, ma non ho trovato nulla con finito per essere più breve.

Mathematica, 131 byte

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

Sono 131 caratteri, inclusi i tre per i=foo;. Sembrava un modo ragionevole di accettare l'input; Avrei potuto metterlo direttamente nella definizione di ce salvare alcuni tratti, ma mi sembra ingiusto.

È piuttosto semplice, quasi persino leggibile. Suddivide la stringa in un elenco di caratteri, quindi inserisce tali caratteri in una matrice sparsa nelle posizioni determinate dal Table(qualsiasi punto della matrice che non assegna un carattere per impostazione predefinita a uno spazio). Le linee sono assemblate separatamente, quindi le nuove linee sono sparse tra loro. L'ultimo StringJoin ricama tutto.

NB: Come alcune altre soluzioni, questo potrebbe non essere valido perché produce un vero sinusoide piuttosto che il (bellissimo) esempio artigianale.

test:

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