Mục tiêu: Viết chương trình hoặc chức năng in chuỗi đầu vào theo hình sin.

Hình sin ASCII

Đây là một giai đoạn của hình sin:

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

Lưu ý rằng có chính xác một dấu chấm trên mỗi cột.

• Mỗi ký tự trong chuỗi đầu vào sẽ thay thế một dấu chấm trong hình trên, từ trái sang phải.
• Không gian trong đầu vào phải được xuất ra như các ký tự bình thường, thay cho dấu chấm.
• Ký tự bắt đầu tương ứng với dấu chấm ngoài cùng bên trái trong hình trên.
• Đây chỉ là một khoảng thời gian, đầu vào có thể dài hơn số lượng dấu chấm ở trên.

Đầu vào

• Đầu vào là các chuỗi ASCII chỉ chứa các ký tự giữa thập phân ASCII 32 (dấu cách) và ASCII thập phân 126 (Tilde ~).
• Đầu vào sẽ luôn là một dòng duy nhất (không ngắt dòng).
• Đầu vào có thể được thực hiện thông qua STDIN, tham số chức năng, đối số dòng lệnh hoặc bất cứ điều gì tương tự.

Đầu ra

• Đầu ra phải được in chính xác như trong các trường hợp thử nghiệm được đưa ra.
• Không gian lưu trữ trên các dòng được cho phép miễn là độ dài của dòng với các khoảng trắng đó không vượt quá độ dài của dòng dài nhất (ký tự có ký tự cuối cùng trên đó).
• Không có đường dẫn / dấu cho phép.

Các trường hợp thử nghiệm

• Đầu vào: .................................................

Đầu ra:

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

• Đầu vào: 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.

Đầu ra:

         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                                   

• Đầu vào: Short text.

Đầu ra:

         t.
      tex  
    t      
   r       
  o        
 h         
S          

• Đầu vào: The quick brown fox jumps over the lazy dog

Đầu ra:

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

                          o                
                           v               
                            er             
                               th       dog
                                 e lazy    

Chấm điểm

Đây là môn đánh gôn , vì vậy chương trình hoặc hàm ngắn nhất tính theo byte sẽ thắng.

Pyth, 59 byte (57 ký tự)

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

Trình diễn.

Một bảng tra cứu nhị phân được mã hóa bên trong ཈, có giá trị 3912. Điều này được chuyển đổi thành nhị phân, cho [1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0]. Điều này được coi là sự khác biệt giữa các độ cao liên tiếp. Bằng cách thêm vào số 6, hình thành tất cả các tiền tố và ánh xạ từng tiền tố vào tổng của nó, quý đầu tiên của sóng được tạo.

sM._+6jC\཈2đánh giá [6, 7, 8, 9, 10, 10, 11, 11, 11, 12, 12, 12, 12]như mô tả ở trên. Sau đó, mã nối vào mặt sau của chuỗi này để tạo thành nửa đầu của sóng và sau đó trừ nó từ 12 để cung cấp cho toàn bộ sóng.

Sau đó, chúng tôi tạo thành các dòng của mỗi ký tự đầu vào theo sau là 12 khoảng trắng. Dòng này được xoay sang phải bởi tham số chiều cao sóng tương ứng với vị trí đó, và sau đó các dòng được hoán vị và nối trên dòng mới.

Sau đó, chúng tôi loại bỏ các dòng trống hàng đầu và dấu. Tuy nhiên, chúng tôi không thể loại bỏ các dòng trống hàng đầu hoặc dấu có khoảng trắng từ đầu vào. Điều này được thực hiện bằng cách thay thế khoảng trắng trong đầu vào bằng các tab ( C9), không thể có trong đầu vào, tước các dòng trống và biến các tab trở lại khoảng trắng.

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]

Giải trình

• Toàn bộ mã chỉ đơn giản là tạo một khối khoảng trắng ( o) và thay thế khoảng trắng bên phải bằng các chữ cái của đầu vào t.

• Biến llưu trữ một danh sách các offset từ đầu. Vì vậy, các nnhân vật thứ tnên được trên dòng l[n].

• Bytearray ophục vụ như một chuỗi có thể thay đổi, vì các chuỗi là bất biến trong python.

• -~hcũng giống như h+1nhưng tiết kiệm không gian vì tôi không cần dấu ngoặc đơn.

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

Tôi vẫn là một người mới ở đây và hy vọng rằng nó tuân thủ các quy tắc để giới thiệu một chức năng phụ (tất nhiên khi các byte của chức năng này được tính). Nếu không, tôi sẽ cố gắng chuyển đổi sinchức năng thành một số tra cứu mảng thông minh ...

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

Đòi hỏi -Echo say, cửa hàng vị trí như số nguyên đúc đến các số nhị phân và lật của mảng có lẽ không phải là rất hiệu quả byte-khôn ngoan. Ngoài ra tôi chắc chắn có rất nhiều tiền tiết kiệm để thực hiện, vì vậy tôi sẽ tiếp tục chọc và chọc.

Ví dụ đầu ra:

$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

Việc thực hiện rất đơn giản: nó sử dụng một chuỗi các ký tự để biểu thị vị trí y của mỗi ký tự trên sóng (được bù bởi a, đó là mã ASCII 97). Sau đó, nó lặp đi lặp lại qua tất cả các hàng có thể; nếu giá trị y của hàng hiện tại giống với vị trí y trên sóng, nó sẽ viết một ký tự từ chuỗi. Ngoài ra còn có một dọn dẹp ở cuối để loại bỏ hàng nếu nó hoàn toàn trống.

Lưu ý rằng đầu ra sẽ xuất hiện rườm rà trong alert()cửa sổ nếu nó không sử dụng phông chữ đơn cách, bạn có thể thay đổi nó console.log()để xác minh đầu ra là chính xác.

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: ++và --tồn tại.

EDIT2: Việc xóa dòng trống hiện được thực hiện trong cùng vòng lặp với phần còn lại, lưu 17 ký tự. Không cần những dấu ngoặc đó, để có thêm 2 ký tự.

EDIT3: Không cần khai báo dạng sóng dưới dạng biến, lưu 4 ký tự.

EDIT4: Như được chỉ ra bởi Dom Hastings trong các bình luận, số byte bao gồm trả về vận chuyển cũng như ký tự dòng mới, đã cập nhật số byte cho tất cả các sửa đổi để loại trừ trả về vận chuyển.

EDIT5: Đã lưu 3 byte lịch sự của Dom Hastings. Tôi đã không thực hiện o.splicesửa lỗi vì điều này không thể xóa các dòng trống (ít nhất là ở phần cuối của tôi).

Matlab, 133 , 130 byte

Một trong những lót:

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

Và phiên bản mở rộng:

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

Một lớp lót lấy đầu vào từ bàn điều khiển ( stdin) và là 130 byte. Phiên bản mở rộng thay thế đầu vào giao diện điều khiển bằng định nghĩa chức năng (+1 byte) nhưng sử dụng thoải mái hơn cho trường hợp thử nghiệm trong một vòng lặp:

Sự miêu tả:

Chỉ số dòng của mỗi ký tự được tính trong một nửa thời gian, sau đó được nhân đôi và ghép để có một khoảng thời gian đầy đủ.
Chúng tôi tạo một nền trống của ký tự khoảng trắng (cùng độ dài với chuỗi đầu vào. Chúng tôi đặt từng ký tự theo vị trí của nó trong dòng có liên quan. Nếu chuỗi đầu vào dài hơn một khoảng thời gian, modtoán tử (modulo) sẽ kết thúc để chúng tôi không ' t ra khỏi ràng buộc khi yêu cầu số dòng.

Trường hợp thử nghiệm:

Lưu phiên bản chức năng textsine.mtrong đường dẫn của bạn, sau đó chạy:

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

sẽ xuất ra:

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    

nếu bạn muốn kiểm tra phiên bản lót với đầu vào từ stdin, đầu vào của bạn phải được nhập như một single string, vì vậy bạn sẽ phải gửi kèm theo đầu vào của bạn giữa 'các nhân vật. Thí dụ:

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

_{Cảm ơn bạn đã Luis Mendocạo lên 3 byte ;-)}

Scala 377 ký tự

nhát cắt đầu tiên. có lẽ có thể có được một công thức tốt hơn để dịch xsangy

(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 thông thường, 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))))

Xét nghiệm

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

Nhận xét

In dòng đầu ra theo dòng, tính toán các chỉ số trong chuỗi nên được in bằng hàm sin ngược asin. Đầu ra không khớp chính xác với các đầu vào dự kiến ​​trong câu hỏi, nhưng vì OP thừa nhận rằng các đầu ra ví dụ không phải là sin thực sự, tôi đoán điều này là ổn. Ít nhất, luôn luôn chỉ có một ký tự được viết cho mỗi cột.

Python 2, 172 byte

Điều này không tốt như câu trả lời của Alex L , nhưng nó khá gần. Lấy đầu vào từ đầu vào tiêu chuẩn và hoạt động tốt nhất trong một .pytệp.

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

Tôi quyết định xây dựng chuyển đổi đầu ra (mỗi cột là một hàng) và sau đó hoán chuyển kết quả, vì trong python sự hoán vị của một ma trận là map(*m).

• l: Biểu diễn nhị phân của 9960000(sau khi cắt "0b"từ bin) là 100101111111101001000000. Đây là "bước" của sóng hình sin mỗi cột, bắt đầu từ ký tự cuối cùng của điểm thấp nhất. Tôi sao chép danh sách này, phủ định từng số và giải quyết nó vào phần cuối của chính nó để tạo thành một đạo hàm của hàm.
• s: Đây là biến theo dõi hàng nào (cột trong chuyển vị) mà ký tự tiếp theo được chèn vào.
• o: Đầu ra cuối, chuyển đổi
• i: Theo dõi chu kỳ sóng hình sin. Bắt đầu từ 9 kể từ khi lđược thay đổi một chút.

Trong forvòng lặp, tôi tạo một danh sách gồm 13 khoảng trắng (tôi đang sử dụng bytearrays nhưng danh sách các ký tự hóa ra có câu lệnh in ngắn hơn), sau đó thay thế ský tự thứ bằng ký tự đầu vào. Nối bvào cuối o, thêm bước thích hợp vào svà tăng dần i.

Tôi đã hy vọng printtuyên bố sẽ đơn giản như \n'.join(*zip(o)), nhưng không có may mắn như vậy. zip(*o+['\n'*13])[::-1]nối thêm một cột các dòng mới và sau đó đảo ngược và hoán chuyển toàn bộ (không có sự đảo ngược, sóng hình sin bị đảo lộn), sum(...,())ghép các bộ dữ liệu lại với nhau thành một bộ ký tự và sau đó ''.join(...)ghép các ký tự và in nó.

Những thứ khác tôi đã thử là tạo ra một mảng 12 ký tự và chèn ký tự mới vào vị trí thích hợp, và thay thế l+=[-c for c in l];bằng một loại toán học với một số phép nhân 1và -1với kết quả của việc lập chỉ mục l, nhưng tôi không thể tìm ra với kết thúc ngắn hơn.

Toán học, 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"]

Đó là 131 ký tự, bao gồm cả ba ký tự i=foo;. Đó dường như là một cách hợp lý để lấy đầu vào; Tôi có thể đã đặt nó thẳng vào định nghĩa cvà lưu lại một vài nét, nhưng điều đó cảm thấy không công bằng.

Nó khá đơn giản - gần như thậm chí có thể đọc được. Nó chia chuỗi thành một danh sách các ký tự và sau đó đặt các ký tự đó thành một mảng thưa thớt tại các vị trí được xác định từ Table(bất kỳ vị trí nào trong mảng không được đặt mặc định cho một ký tự vào khoảng trắng). Các dòng được lắp ráp riêng biệt, sau đó dòng mới rắc giữa chúng. StringJoin cuối cùng khâu tất cả lên.

Lưu ý: Giống như một số giải pháp khác, điều này có thể không thực sự hợp lệ vì nó tạo ra một hình sin thực sự chứ không phải là ví dụ thủ công (đẹp).

Các xét nghiệm:

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