Ziel: Schreiben Sie ein Programm oder eine Funktion, die eine Eingabezeichenfolge in einer sinusförmigen Form ausgibt.

Die ASCII-Sinuskurve

Hier ist eine Periode der Sinusform:

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

Beachten Sie, dass sich auf jeder Spalte genau ein Punkt befindet.

• Jedes Zeichen in der Eingabezeichenfolge ersetzt einen Punkt in der obigen Form von links nach rechts.
• Leerzeichen in der Eingabe müssen wie normale Zeichen anstelle eines Punkts ausgegeben werden.
• Das Startzeichen entspricht dem Punkt ganz links in der obigen Abbildung.
• Dies ist nur eine Periode, Eingaben können länger als die Anzahl der obigen Punkte sein.

Eingang

• Eingaben sind ASCII-Zeichenfolgen, die nur Zeichen zwischen ASCII-Dezimalstelle 32 (Leerzeichen) und ASCII-Dezimalstelle 126 (Tilde ~) enthalten.
• Eingänge bestehen immer nur aus einer Zeile (keine Zeilenumbrüche).
• Eingaben können über STDIN, Funktionsparameter, Befehlszeilenargumente oder ähnliches erfolgen.

Ausgabe

• Die Ausgabe muss genau wie in den angegebenen Testfällen gedruckt werden.
• Nachgestellte Leerzeichen in Zeilen sind zulässig, solange die Länge der Zeile mit diesen nachgestellten Leerzeichen die Länge der längsten Zeile (die mit dem letzten Zeichen) nicht überschreitet.
• Keine führende / nachfolgende Linie erlaubt.

Testfälle

• Eingang: .................................................

Ausgabe:

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

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

Ausgabe:

         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                                   

• Eingang: Short text.

Ausgabe:

         t.
      tex  
    t      
   r       
  o        
 h         
S          

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

Ausgabe:

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

                          o                
                           v               
                            er             
                               th       dog
                                 e lazy    

Wertung

Das ist Code-Golf , also gewinnt das kürzeste Programm oder die kürzeste Funktion in Bytes.

Pyth, 59 Bytes (57 Zeichen)

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

Demonstration.

཈Darin ist eine binäre Nachschlagetabelle codiert , die den Wert 3912 hat. Diese wird in eine binäre Nachschlagetabelle konvertiert [1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0]. Dies wird als der Unterschied zwischen aufeinanderfolgenden Höhen behandelt. Durch Voranstellen einer 6, Bilden aller Präfixe und Zuordnen jeder zu ihrer Summe wird das erste Viertel der Welle erzeugt.

sM._+6jC\཈2wird [6, 7, 8, 9, 10, 10, 11, 11, 11, 12, 12, 12, 12]wie oben beschrieben ausgewertet . Dann verkettet sich der Code auf der Rückseite dieser Zeichenfolge, um die erste Hälfte der Welle zu bilden, und subtrahiert sie dann von 12, um die gesamte Welle zu ergeben.

Dann bilden wir Zeilen für jedes Eingabezeichen, gefolgt von 12 Leerzeichen. Diese Linie wird um den dieser Position entsprechenden Wellenhöhenparameter nach rechts gedreht, und dann werden die Linien auf neuen Linien transponiert und verbunden.

Dann entfernen wir führende und nachfolgende Leerzeilen. Führende oder nachfolgende Leerzeilen, die Leerzeichen enthalten, können jedoch nicht entfernt werden. Dies wird implementiert, indem Leerzeichen in der Eingabe durch Tabulatoren ( C9) ersetzt werden, die nicht in der Eingabe enthalten sind, leere Zeilen entfernt und die Tabulatoren wieder in Leerzeichen umgewandelt werden.

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]

Erläuterung

• Der gesamte Code erstellt einfach einen Block mit Leerzeichen ( o) und ersetzt die richtigen Leerzeichen durch die Buchstaben der Eingabe t.

• Die Variable lspeichert eine Liste von Offsets von oben. Damit das nth Zeichen von tonline sein sollte l[n].

• Das Bytearray odient als veränderbare Zeichenfolge, da Zeichenfolgen in Python unveränderlich sind.

• -~hist das gleiche wie h+1aber spart Platz, da ich keine Klammern brauche.

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

Ich bin hier noch ein Neuling und hoffe, dass es den Regeln entspricht, eine Unterfunktion einzuführen (wenn die Bytes dieser Funktion natürlich gezählt werden). Wenn nicht, werde ich versuchen, die sinFunktion in eine clevere Array-Suche umzuwandeln ...

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

Requires -Efor sayspeichert die Positionen als Ganzzahlen, die in Binärzahlen umgewandelt werden, und das Umkehren des Arrays ist in Bezug auf die Bytes wahrscheinlich nicht sehr effizient. Ich bin mir auch sicher, dass es viel zu sparen gibt, also werde ich weiter stochern und stupsen.

Beispielausgabe:

$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

Wirklich einfache Implementierung: Es wird eine Zeichenfolge verwendet, um die y-Position jedes Zeichens auf der Welle darzustellen (versetzt um a, was ASCII-Code 97 ist). Anschließend werden alle möglichen Zeilen durchlaufen. Wenn der y-Wert der aktuellen Zeile mit der y-Position auf der Welle übereinstimmt, wird ein Zeichen aus der Zeichenfolge geschrieben. Es gibt auch eine Bereinigung am Ende, um die Zeile zu entfernen, wenn sich herausstellt, dass sie vollständig leer ist.

Beachten Sie, dass die Ausgabe im alert()Fenster wackelig erscheint, wenn keine monospaced Schriftart verwendet wird. Sie können diese in ändern, console.log()um sicherzustellen, dass die Ausgabe korrekt ist.

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: ++und --existieren.

EDIT2: Das Entfernen von Leerzeilen erfolgt jetzt in derselben Schleife wie der Rest und spart 17 Zeichen. Benötigte diese Klammern auch nicht, für zusätzliche 2 Zeichen.

EDIT3: Es ist nicht erforderlich, die Wellenform als Variable zu deklarieren und 4 Zeichen zu speichern.

EDIT4: Wie Dom Hastings in den Kommentaren hervorhob, enthielt die Byteanzahl den Zeilenumbruch sowie das Zeilenumbruchzeichen und aktualisierte die Byteanzahl für alle Überarbeitungen, um den Zeilenumbruch auszuschließen.

EDIT5: 3 Bytes mit freundlicher Genehmigung von Dom Hastings gespeichert. Ich habe das o.spliceUpdate nicht implementiert, da hierdurch die Leerzeilen nicht entfernt werden können (zumindest an meinem Ende).

Matlab, 133 , 130 Bytes

Der eine Liner:

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

Und die erweiterte Version:

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

Der eine Liner nimmt Eingaben von der Konsole ( stdin) entgegen und ist 130 Byte groß. Die erweiterte Version ersetzt die Konsoleneingabe durch eine Funktionsdefinition (+1 Byte), ist jedoch für den Testfall in einer Schleife wesentlich komfortabler zu verwenden:

Beschreibung:

Der Zeilenindex jedes Zeichens wird für eine halbe Periode berechnet, dann gespiegelt und verkettet, um eine volle Periode zu erhalten.
Wir erstellen einen leeren Hintergrund aus Whitespace-Zeichen (dieselbe Länge wie die Eingabezeichenfolge. Wir platzieren jedes Zeichen entsprechend seiner Position in der entsprechenden Zeile. Wenn die Eingabezeichenfolge länger als eine Periode ist, modbricht der (Modulo) -Operator das um, damit wir nicht ' Beim Anfordern der Zeilennummer kommt man nicht aus der Schranke.

Testfall:

Speichern Sie die Funktionsversion unter textsine.min Ihrem Pfad und führen Sie dann Folgendes aus:

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

wird ausgeben:

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    

Wenn Sie die One-Liner-Version mit Eingabe von testen möchten stdin, muss Ihre Eingabe als eine einzige eingegeben werden string, sodass Sie Ihre Eingabe zwischen 'Zeichen einschließen müssen . Beispiel:

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

_{Danke, Luis Mendodass du 3 Bytes gespart hast ;-)}

Scala 377 Zeichen

erster Schnitt. wahrscheinlich eine bessere Formel erhalten übersetzen xzuy

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

Common Lisp, 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))))

Tests

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

Bemerkungen

Drucken Sie die Ausgabe zeilenweise aus. Berechnen Sie dabei die Indizes in den Zeichenfolgen, die mit der Sinusumkehrfunktion gedruckt werden sollen asin. Die Ausgaben stimmen nicht genau mit den erwarteten Eingaben in der Frage überein, aber da OP bestätigt, dass die Beispielausgaben nicht wirklich sinusförmig sind, denke ich, dass dies in Ordnung ist. Zumindest wird für jede Spalte immer nur ein Zeichen geschrieben.

Python 2, 172 Bytes

Dies ist nicht so gut wie die Antwort von Alex L. , aber es ist ziemlich nah. Übernimmt die Eingabe von der Standardeingabe und funktioniert am besten in einer .pyDatei.

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

Ich habe beschlossen, die Ausgabe transponiert (jede Spalte ist eine Zeile) und dann das Ergebnis zu transponieren, da in Python die Transponierung einer Matrix ist map(*m) .

• l: Die binäre Darstellung von 9960000(nach dem Abhacken des "0b"vonbin ) ist 100101111111101001000000. Dies ist der "Schritt" der Sinuswelle jeder Spalte, beginnend mit dem allerletzten Zeichen des tiefsten Punkts. Ich kopiere diese Liste, negiere jede Zahl und setze sie an das Ende ihrer selbst, um eine Ableitung der Funktion zu bilden.
• s: Dies ist die Variable, die festhält, in welcher Zeile (Spalte in der Transponierung) das nächste Zeichen eingefügt wird.
• o: Ausgabe beenden, transponiert
• i: Verfolgt die Sinuswellenperiode. Beginnt bei 9, da lleicht verschoben.

In der forSchleife erstelle ich eine Liste mit 13 Leerzeichen (ich habe Bytearrays verwendet, aber die Liste der Zeichen enthält eine kürzere print-Anweisung) und ersetze dann das sth-Zeichen durch das Eingabezeichen. Anfügen ban das Ende o, fügen Sie den entsprechenden Schritt zu sund Inkrementi .

Ich hatte gehofft, dass die printAussage so einfach sein würde \n'.join(*zip(o)), aber kein solches Glück. zip(*o+['\n'*13])[::-1]Hängt eine Spalte mit Zeilenumbrüchen an, kehrt das Ganze um und transponiert es (ohne Umkehrung ist die Sinuswelle verkehrt herum), sum(...,())verkettet die Tupel zu einem Tupel von Zeichen und dann''.join(...) verkettet die Zeichen und druckt es aus.

Andere Dinge, die ich versuchte, waren, ein 12-stelliges Array von Leerzeichen zu erstellen, das neue Zeichen an der entsprechenden Stelle einzufügen und durch l+=[-c for c in l];eine Art Mathematik mit einer Art Multiplikation 1und -1mit dem Ergebnis der Indizierung zu ersetzen l, aber nichts, worauf ich kommen konnte mit am Ende kürzer zu sein.

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

Das sind 131 Zeichen, einschließlich der drei für i=foo;. Das schien ein vernünftiger Weg zu sein, um den Input aufzunehmen. Ich hätte es direkt in die Definition von einfügen könnenc einfügen und ein paar Striche sparen können, aber das fühlt sich unfair an.

Es ist ziemlich einfach - fast sogar lesbar. Es teilt die Zeichenfolge in eine Liste von Zeichen auf und fügt diese Zeichen dann an den von bestimmten Positionen in ein spärliches Array ein Table(für jede Stelle im Array, der kein Zeichen zugewiesen wurde, wird standardmäßig ein Leerzeichen verwendet). Die Leitungen werden separat zusammengesetzt und dann mit neuen Leitungen dazwischen bestreut. Das finale StringJoin fügt alles zusammen.

NB: Wie bei einigen anderen Lösungen ist dies möglicherweise nicht wirklich gültig, da es eher eine echte Sinusform als das (schöne) handgefertigte Beispiel ergibt.

Tests:

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