Objectif: écrire un programme ou une fonction qui imprime une chaîne d'entrée sous une forme sinusoïdale.

La sinusoïde ASCII

Voici une période de la sinusoïde:

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

Notez qu'il y a exactement un point sur chaque colonne.

• Chaque caractère de la chaîne d'entrée remplacera un point dans la forme ci-dessus, de gauche à droite.
• Les espaces dans l'entrée doivent être sortis comme des caractères normaux, à la place d'un point.
• Le caractère de départ correspond au point le plus à gauche de la figure ci-dessus.
• Ce n'est qu'une période, les entrées peuvent être plus longues que le nombre de points ci-dessus.

Contribution

• Les entrées sont des chaînes ASCII qui contiennent uniquement des caractères entre ASCII décimal 32 (espace) et ASCII décimal 126 (Tilde ~).
• Les entrées seront toujours une seule ligne (pas de sauts de ligne).
• Les entrées peuvent être prises via STDIN, les paramètres de fonction, les arguments de ligne de commande ou quelque chose de similaire.

Sortie

• La sortie doit être imprimée exactement comme dans les cas de test donnés.
• Les espaces de fin sur les lignes sont autorisés tant que la longueur de la ligne avec ces espaces de fin ne dépasse pas la longueur de la ligne la plus longue (celle qui contient le dernier caractère).
• Aucune ligne avant / arrière autorisée.

Cas de test

• Contribution: .................................................

Sortie:

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

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

Sortie:

         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                                   

• Contribution: Short text.

Sortie:

         t.
      tex  
    t      
   r       
  o        
 h         
S          

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

Sortie:

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

                          o                
                           v               
                            er             
                               th       dog
                                 e lazy    

Notation

C'est le code-golf , donc le programme ou la fonction la plus courte en octets l'emporte.

Pyth, 59 octets (57 caractères)

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

Manifestation.

Une table de recherche binaire est codée à l'intérieur ཈, qui a la valeur 3912. Elle est convertie en binaire, donnant [1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0]. Ceci est traité comme les différences entre des hauteurs consécutives. En ajoutant un 6, en formant tous les préfixes et en les mappant chacun à sa somme, le premier quart de l'onde est généré.

sM._+6jC\཈2s'évalue [6, 7, 8, 9, 10, 10, 11, 11, 11, 12, 12, 12, 12]comme décrit ci-dessus. Ensuite, le code concatène à l'envers de cette chaîne pour former la première moitié de l'onde, puis la soustrait de 12 pour donner l'onde entière.

Ensuite, nous formons des lignes de chaque caractère saisi suivies de 12 espaces. Cette ligne est tournée vers la droite par le paramètre de hauteur de vague correspondant à cet emplacement, puis les lignes sont transposées et jointes sur des nouvelles lignes.

Ensuite, nous supprimons les lignes vides de début et de fin. Cependant, nous ne pouvons pas supprimer les lignes vides de début ou de fin qui ont des espaces dans l'entrée. Ceci est implémenté en remplaçant les espaces dans l'entrée par des tabulations ( C9), qui ne peuvent pas être dans l'entrée, en supprimant les lignes vides et en transformant les tabulations en espaces.

Python 2, 156 octets

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]

Explication

• Le code entier fait simplement un bloc d'espaces ( o) et remplace les bons espaces par les lettres de l'entrée t.

• La variable lstocke une liste de décalages par le haut. Pour que le ncaractère e tsoit en ligne l[n].

• Le bytearray osert de chaîne modifiable, car les chaînes sont immuables en python.

• -~hest le même que h+1mais économise de l'espace car je n'ai pas besoin de parenthèses.

Java, 219 209 199 octets

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

Je suis toujours un débutant ici, et j'espère qu'il est conforme aux règles d'introduire une sous-fonction (lorsque les octets de cette fonction sont comptés, bien sûr). Sinon, je vais essayer de convertir la sinfonction en une recherche de tableau 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 octets

$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

Requiert -Epour say, stocke les positions sous forme d'entiers convertis en nombres binaires et le retournement du tableau n'est probablement pas très efficace en octets. De plus, je suis sûr qu'il y a beaucoup d'économies à faire, donc je continuerai à pousser et à pousser.

Exemple de sortie:

$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

Implémentation vraiment simple: il utilise une chaîne de caractères pour représenter la position y de chaque caractère sur l'onde (décalé par a, qui est le code ASCII 97). Il parcourt ensuite toutes les lignes possibles; si la valeur y de la ligne actuelle est la même que la position y sur l'onde, elle écrit un caractère dans la chaîne. Il y a aussi un nettoyage à la fin pour supprimer la ligne si elle s'avère complètement vide.

Notez que la sortie apparaîtra dans la alert()fenêtre si elle n'utilise pas de police à espacement fixe, vous pouvez la modifier console.log()pour vérifier que la sortie est correcte.

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: ++et --existent.

EDIT2: La suppression des lignes vides se fait maintenant dans la même boucle que le reste, économisant 17 caractères. Je n'ai pas eu besoin de ces crochets non plus, pour 2 caractères supplémentaires.

EDIT3: Pas besoin de déclarer la forme d'onde en tant que variable, enregistrant 4 caractères.

EDIT4: Comme l'a souligné Dom Hastings dans les commentaires, le nombre d'octets comprenait le retour chariot ainsi que le caractère de nouvelle ligne, mis à jour le nombre d'octets pour toutes les révisions pour exclure le retour chariot.

EDIT5: Sauvegardé 3 octets avec la permission de Dom Hastings. Je n'ai pas implémenté le o.splicecorrectif car cela ne supprime pas les lignes vides (de mon côté, au moins).

Matlab, 133 , 130 octets

La doublure unique:

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

Et la version étendue:

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

La doublure prend l'entrée de la console ( stdin) et fait 130 octets. La version étendue remplace l'entrée console par une définition de fonction (+1 octet) mais est beaucoup plus confortable à utiliser pour le cas de test en boucle:

La description:

L'index de ligne de chaque caractère est calculé pour une demi-période, puis mis en miroir et concaténé pour avoir une période complète.
Nous créons un arrière-plan vierge de caractères d'espacement (même longueur que la chaîne d'entrée. Nous plaçons chaque caractère selon sa position dans la ligne appropriée. Si la chaîne d'entrée est plus longue qu'une période, l' modopérateur (modulo) encapsule cela donc nous ne le faisons pas ' t sortir de la limite lors de la demande du numéro de ligne.

Cas de test:

Enregistrez la version de la fonction sous textsine.mdans votre chemin, puis exécutez:

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

affichera:

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 vous voulez tester la version à une ligne avec une entrée de stdin, votre entrée doit être entrée comme une seule string, vous devez donc entourer votre entrée entre les 'caractères. Exemple:

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

_{Merci d' Luis Mendoavoir rasé 3 octets ;-)}

Scala 377 caractères

première Coupe. peut probablement obtenir une meilleure formule à traduire xeny

(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 commun, 205 octets

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

Les tests

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

Remarques

Imprimez la sortie ligne par ligne, en calculant les indices dans les chaînes qui doivent être imprimées à l'aide de la fonction sinus inverse asin. Les sorties ne correspondent pas exactement aux entrées attendues dans la question, mais comme OP reconnaît que les sorties d'exemple ne sont pas vraiment sinusoïdales, je suppose que c'est correct. Au moins, il n'y a toujours qu'un seul caractère écrit pour chaque colonne.

Python 2, 172 octets

Ce n'est pas aussi bon que la réponse d'Alex L , mais c'est assez proche. Prend l'entrée de l'entrée standard et fonctionne mieux dans un .pyfichier.

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

J'ai décidé de construire la sortie transposée (chaque colonne est une ligne) puis de transposer le résultat, car en python la transposition d'une matrice est map(*m).

• l: La représentation binaire de 9960000(après avoir coupé le "0b"from bin) est 100101111111101001000000. Il s'agit du "pas" de l'onde sinusoïdale de chaque colonne, en commençant par le tout dernier caractère du point le plus bas. Je copie cette liste, j'annule chaque nombre et je le cloue à la fin de lui-même pour former ce qui est effectivement un dérivé de la fonction.
• s: Il s'agit de la variable qui conserve la trace de la ligne (colonne de la transposition) dans laquelle le caractère suivant est inséré.
• o: Sortie finale, transposée
• i: Garde une trace de la période d'onde sinusoïdale. Commence à 9 car lest légèrement décalé.

Dans la forboucle, je crée une liste de 13 espaces (j'utilisais des tableaux croisés mais les listes de caractères se révèlent avoir une instruction d'impression plus courte), puis je remplace le se caractère par le caractère d'entrée. Ajoutez bà la fin de o, ajoutez l'étape appropriée set incrémentez i.

J'avais espéré que la printdéclaration serait aussi simple que \n'.join(*zip(o)), mais pas de chance. zip(*o+['\n'*13])[::-1]ajoute une colonne de nouvelles lignes, puis inverse et transpose le tout (sans l'inversion, l'onde sinusoïdale est à l'envers), sum(...,())concatène les tuples ensemble en un tuple de caractères, puis ''.join(...)concatène les caractères et l'imprime.

D'autres choses que j'ai essayées étaient de créer un tableau d'espaces de 12 caractères et d'insérer le nouveau caractère à l'endroit approprié, et de le remplacer l+=[-c for c in l];par une sorte de calcul avec une sorte de multiplication 1et -1avec le résultat de l'indexation dans l, mais rien que je ne pouvais trouver avec fini par être plus court.

Mathematica, 131 octets

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

Cela fait 131 caractères, dont les trois pour i=foo; . Cela semblait une façon raisonnable de recueillir les commentaires; J'aurais pu le mettre directement dans la définition de cet sauvé quelques coups, mais cela semble injuste.

C'est assez simple - presque même lisible. Il divise la chaîne en une liste de caractères, puis place ces caractères dans un tableau clairsemé aux positions déterminées à partir de laTable (tout endroit du tableau auquel aucun caractère n'a été attribué par défaut est un espace). Les lignes sont assemblées séparément, puis des nouvelles lignes saupoudrées entre elles. Le dernier StringJoin assemble le tout.

NB: Comme certaines autres solutions, cela peut ne pas être valable car cela produit une véritable sinusoïde plutôt que le (bel) exemple artisanal.

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