Écrivez un programme ou une fonction qui, étant donné une chaîne d'entrée et un écart-type σ, sort cette chaîne le long de la courbe de distribution normale avec la moyenne 0et l'écart-type σ.

Courbe de distribution normale

Les ycoordonnées de chaque caractère csont:

où σest donné en entrée et où xest la xcoordonnée de l' axe de c.

• Le caractère au centre de la chaîne a x = 0. Si la longueur de la chaîne est paire, l'un des deux caractères du milieu peut être choisi comme centre.
• Les caractères sont séparés par des pas de 0.1(par exemple, le caractère à gauche du centre que l'on a x = -0.1, celui à droite du milieu a x = 0.1, etc.).

Impression de la chaîne

• Les lignes, comme les caractères, sont séparées par des pas de 0.1.
• Chaque caractère est imprimé sur la ligne avec la yvaleur qui se rapproche le plus de sa propre yvaleur (si la valeur se situe précisément entre les valeurs de deux lignes, choisissez celle qui a la plus grande valeur (tout comme le roundretourne habituellement 1.0pour 0.5)).
• Par exemple, si la ycoordonnée de la valeur centrale (c'est-à-dire la valeur maximale) est 0.78et la ycoordonnée du premier caractère est 0.2, alors il y aura 9 lignes: le caractère central étant imprimé en ligne 0et le premier caractère étant imprimé en ligne 8.

Entrées et sorties

• Vous pouvez prendre les deux entrées (la chaîne et σ) comme arguments de programme, via STDIN, arguments de fonction ou tout autre élément similaire dans votre langue.
• La chaîne ne contiendra que des caractères imprimables ASCII. La chaîne peut être vide.
• σ > 0.
• Vous pouvez imprimer la sortie STDOUTdans un fichier ou la renvoyer à partir d'une fonction ( tant qu'il s'agit d'une chaîne et non pas d'une liste de chaînes pour chaque ligne).
• Une nouvelle ligne de fin est acceptable.
• Les espaces de fin sont acceptables tant qu'ils ne font pas dépasser la ligne de la dernière ligne (donc aucun espace de fin n'est acceptable sur la dernière ligne).

Cas de test

σ    String

0.5  Hello, World!

     , W     
   lo   or   
  l       l  
 e         d 
H           !



0.5  This is a perfectly normal sentence

                tly                
              ec    n              
             f       o             
            r         r            
           e           m           
          p             a          
        a                l         
      s                    se      
This i                       ntence



1.5  Programming Puzzles & Code Golf is a question and answer site for programming puzzle enthusiasts and code golfers.

                                                d answer site for p                                               
                                      uestion an                   rogramming                                     
                      Code Golf is a q                                        puzzle enthusia                     
Programming Puzzles &                                                                        sts and code golfers.



0.3  .....................

          .          
         . .         

        .   .        

       .     .       


      .       .      

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

Notation

C'est du golf de code ,

                 nsw                 
                a   er               
              t                      
             s         i             
            e           n            
           t                         
         or               by         
       sh                   te       
so the                        s wins.

Python 3 avec SciPy , 239 233 octets

from scipy import stats,around,arange
def f(s,t):
 l=len(t);p=[];y=around(stats.norm.pdf((arange(l)-l//2)*.1,scale=s),1)*10
 for i in range(l):p+=[[' ']*(max(y)-y[i])];p[i]+=[t[i]]+[' ']*(y[i]-y[0])
 for j in zip(*p):print(*j,sep='')

Une fonction qui prend l'entrée via l'argument de l'écart-type set de la chaîne tet imprime le résultat dans STDOUT.

Comment ça fonctionne

from scipy import stats,around,arange  Import the statistics, rounding and range functions
                                       from SciPy
def f(s,t):                            Function with input standard deviation s and string
                                       t
l=len(t);p=[]                          Define the much-used length of t as l and initialise
                                       the print values list p
arange(l)                              Generate a list of integer x values in [0,l)...
...-l//2*.1                            ...and scale such that 0 is at the middle character
                                       and the x-step is 0.1
stats.norm.pdf(...,scale=s)            Generate a list containing the y values for each x
                                       value by calling the normal probability
                                       density function scaled with s...
y=around(...,1)                        ...round all values to 1 decimal place...
...*10                                 ...and multiply by 10 to give the vertical index of
                                       each character
for i in range(l):...                  For all characters in t...
p+=[[' ']*(max(y)-y[i])]               ..add the number of lines below the character as
                                       spaces...
p[i]+=[t[i]]+[' ']*(y[i]-y[0])         ...add the character and the number of lines above
                                       the character as spaces

This leaves p containing a list for each desired output line, but transposed.

for j in zip(*p):...                   For every output line in the transpose of p...
print(*j,sep='')                       ...print the output line

Essayez-le sur Ideone

Rubis: 273 254 octets

->n,s{j,o,g,r,l=-(n.size/2),[],0,{}
n.gsub(/./){(r[((2*Math::PI)**-0.5*10*Math.exp(-(j/1e1)**2/2/s/s)/s).round]||="")<<$&
j+=1}
r.sort.map{|y, c|o<<(l ?$/*(y-l-1):"")+(" "*g)+(c[0,(h=c.size)/2])+(" "*(n.size-g*2-h))+(c[h/2,h])
g+=h/2
l=y}
puts o.reverse}

Un grand merci à Kevin Lau pour avoir économisé 18 octets!