Dòng đầu tiên được thực hiện với ceil(n/2)các phần tử trong đó mỗi phần tử là:<space><odd-number><space>

Dòng thứ hai được tạo với ceil(n/2)các phần tử, nhưng mỗi phần tử / \chỉ.

Bạn có thể giả định n >= 0và n <= 10.

Ví dụ

Đầu vào: 3

 1  3
/ \/ \

Đầu vào: 10

 1  3  5  7  9
/ \/ \/ \/ \/ \

Ví dụ trong Python 3, 103 byte:

lambda a:print("".join([" "+str(i)+" "for i in range(1,a+1,2)]+["\n"]+["/ \\"for i in range(1,a+1,2)]))

Mã ngắn nhất tính bằng byte thắng :)

05AB1E , 19 15 14 12 byte

05AB1E sử dụng mã hóa CP-1252 .
Đã lưu 4 byte nhờ Adnan .
Đã lưu 2 byte nhờ tính toán carusocomputing

ÅÉðìDg…/ \×»

Hãy thử trực tuyến!

Giải trình

ÅÉ               # list of uneven number up to input
  ðì             # prepend a space to each
    Dg           # get length of list
      …/ \       # push the string "/ \"
          ×      # repeat the string length-list times
           »     # join rows by spaces and columns by newlines

Pyke, 16 byte

S2%idm+dJil*"/ \

Hãy thử nó ở đây!

17 byte và tuyệt vời hơn

S2%i`~Bd.:il*"/ \

Hãy thử nó ở đây!

Điều này sử dụng IMHO một thuật toán TUYỆT VỜI để đảm bảo dòng đầu tiên được căn chỉnh chính xác.

S                 - range(1, input+1)
 2%               -  ^[::2]
   i              -   i = ^
    `             -    str(^)
     ~Bd.:        -     ^.translate("><+-.,[]", " ") <-- awesome bit here
          il      -  len(i)
            *"/ \ - ^ * "/ \"

Điều này thay thế tất cả các ký tự trong danh sách được xâu chuỗi bằng dấu cách. ~Bchứa tất cả các ký tự trong ngôn ngữ Brain **** và đây là lần đầu tiên tôi sử dụng biến này.

Chương trình `~Bd.:thực hiện điều này:

`~Bd.: - input = [1, 3, 5, 7]
`      - str(input)  # stack now ["[1, 3, 5, 7]"]
 ~B    - "><+-.,[]"  # stack now ["[1, 3, 5, 7]", "><+-.,[]"]
   d   - " "         # stack now ["[1, 3, 5, 7]", "><+-.,[]", " "]
    .: - translate() # stack now [" 1  3  5  7 "]

Python 2, 63 byte

lambda n:' '.join(n%2*`n`for n in range(n+1))+'\n'+-~n/2*'/ \\'

Một mẹo nhỏ cho dòng đầu tiên: nó không in các số chẵn, nhưng coi chúng là một chuỗi trống, dẫn đến bắt đầu không gian trống (0 sẽ ở đó) và nhân đôi khoảng cách giữa các số mà không có bất kỳ sửa đổi nào trong phạm vi, nhược điểm là không gian hàng đầu trong số chẵn n

Python 2 3, 67 65 63 60 byte

Không có gì quá điên rồ ở đây, tôi nghĩ phần đầu tiên có thể được thực hiện ngắn hơn nhưng tôi không chắc lắm . Tôi sử dụng thực tế là trong trường hợp -~n/2này sẽ làm việc cho ceil.

lambda n:-~n//2*' %d '%(*range(1,n+1,2),)+'\n'+-~n//2*'/ \\'

Dưới đây là các giải pháp thay thế 61 và 65 byte trong Python 2:

lambda n:-~n/2*' %d '%tuple(range(1,n+1,2))+'\n'+-~n/2*'/ \\'
lambda n:' '+'  '.join(map(str,range(1,n+1,2)))+'\n'+-~n/2*'/ \\'

^{Cảm ơn Rod đã lưu 2 byte và Artyer để lưu một byte khác bằng cách chuyển đổi phiên bản :)}

JavaScript (ES6), 55 byte

f=n=>n%2?f(n-1).replace(`
`,` ${n} 
/ \\`):n?f(n-1):`
`

<input type=number min=1 max=10 oninput=o.textContent=f(this.value)><pre id=o>

Lưu ý không gian ở cuối dòng thứ hai.

Python 2, 53 byte

lambda n:" 1  3  5  7  9"[:-~n/2*3]+'\n'+-~n/2*"/ \\"

Tận dụng lợi thế của hạn chế n <= 10để tạo dòng trên cùng bằng cách cắt một đoạn từ chuỗi mã hóa cứng.

Đầu ra cho 1 đến 10 là

 1 
/ \
 1 
/ \
 1  3 
/ \/ \
 1  3 
/ \/ \
 1  3  5 
/ \/ \/ \
 1  3  5 
/ \/ \/ \
 1  3  5  7 
/ \/ \/ \/ \
 1  3  5  7 
/ \/ \/ \/ \
 1  3  5  7  9
/ \/ \/ \/ \/ \
 1  3  5  7  9
/ \/ \/ \/ \/ \

Đầu ra cho 0 là hai dòng trống.

Vim, 73 59 56 byte

Đây là một IMO số byte thực sự cao cho những gì có vẻ như là một vấn đề đơn giản. Tôi cảm thấy như tôi đang thiếu một cái gì đó rõ ràng.

caw="/2*2
caw1357911/"
DYp:s;.;/ \\;g
k:s// & /g

Hãy thử trực tuyến!

Không thể in

^Acaw^R=^R"/2*2      # Transform a number into the next odd number (3->5,4>5)
^[^Acaw1357911^[/^R" # Insert 1357911, delete everything after the number above
DYp:s;.;/ \\;g       # Duplicate the line, replace numbers with / \
k:s// & /g           # On the line above, add spaces around numbers
<trailing newline>

Toán học, 65 byte

" "<>Range[1,#,2]~StringRiffle~"  "<>"
"<>"/ \\"~Table~⌈#/2⌉&

Chức năng ẩn danh. Lấy một số làm đầu vào và trả về một chuỗi làm đầu ra. Các ký tự Unicode, tương ứng, là U + 2308 LEFT CEILING cho \[LeftCeiling]và U + 2309 RIGHT CEILING cho \[RightCeiling].

WinDbg, 100 byte

.echo;.for(r$t1=1;@$t1<=2*@$t0+@$t0%2;r$t1=@$t1+2){j@$t1<=@$t0 .printf"\b %d \n",@$t1;.printf"/ \\"}

Đầu vào được thực hiện bằng cách đặt một giá trị trong thanh ghi giả $t0.

Có vẻ như nó ngắn nhất ở đây chỉ để in chuỗi khi nó được xây dựng thay vì cố gắng xây dựng nó trước và hiển thị toàn bộ. Tôi sẽ có một giải pháp ngắn hơn nếu WinDbg cho phép tôi viết thư để giải quyết 0.

Làm thế nào nó hoạt động:

.echo;                                            * Print a new line that'll be deleted
.for(r$t1=1; @$t1 <= 2*@$t0+@$t0%2; r$t1=@$t1+2)  * Enumerate 1 to 4*ceil($t0/2), count by 2
{
    j@$t1<=@$t0                                   * If $t1 <= $t0...
        .printf"\b %d \n",@$t1;                   * ...Print $t1 (and newline for last n)
        .printf"/ \\"                             * ...Else print the / \'s
}

Đầu ra cho mỗi giá trị của n:

0:000> .for(r$t0=0;b>@$t0;r$t0=@$t0+1){.printf"\n\nn=%d\n",@$t0; .echo;.for(r$t1=1;@$t1<=2*@$t0+@$t0%2;r$t1=@$t1+2){j@$t1<=@$t0 .printf"\b %d \n",@$t1;.printf"/ \\"}}


n=0



n=1
 1 
/ \

n=2
 1 
/ \

n=3
 1  3 
/ \/ \

n=4
 1  3 
/ \/ \

n=5
 1  3  5 
/ \/ \/ \

n=6
 1  3  5 
/ \/ \/ \

n=7
 1  3  5  7 
/ \/ \/ \/ \

n=8
 1  3  5  7 
/ \/ \/ \/ \

n=9
 1  3  5  7  9 
/ \/ \/ \/ \/ \

n=10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

> <> (CÁ), 69 60 68 55 byte

5|v&+%1:,2
1->:?!v:
8~v!?l<on$o:*4
a&/o
1->:?!;"\ /"ooo

Dán nó vào phiên dịch trực tuyến này!

Số 5 trên dòng đầu tiên là giá trị đầu vào của bạn (mã hóa cứng là 5, được thay thế bằng 0-a hoặc i cho đầu vào của người dùng).

Chỉnh sửa 1: Đã chuyển vị trí dòng mới vào không gian dòng đầu tiên (trống) để lưu 9 byte tổng thể trên không gian từ một dòng mới.

Chỉnh sửa 2: Theo ghi nhận của người dùng7150406, đầu ra bị sai (không in dấu cách), điều này đã được sửa với việc mất 8 byte.

Chỉnh sửa 3: thay đổi hoàn toàn logic, không có điểm kiểm tra nếu số đó là số lẻ - thay vào đó hãy đặt tất cả các số trên ngăn xếp và xóa từng giây. Byte đã lưu 13!

Java, 118 112 byte

Chỉnh sửa: Đã lưu 6 byte nhờ @peech

Chơi gôn

String M(int n){String o=" ";int i=1;n+=1;for(;i<n;i+=2)o+=i+"  ";o+="\n";for(i=0;i<n/2;i++)o+="/ \\";return o;}

Ung dung:

public String M(int n)
{
    String o = " ";
    int i=1;
    n += 1;
    for (; i < n;i+=2)
        o += i + "  ";
    o += "\n";
    for (i = 0; i < n/2; i++)
        o += "/ \\";
    return o;  
}

Kiểm tra:

    OddMountains om = new OddMountains();
    System.out.println(om.M(1));
    System.out.println();
    System.out.println(om.M(3));
    System.out.println();
    System.out.println(om.M(5));
    System.out.println();
    System.out.println(om.M(7));
    System.out.println();
    System.out.println(om.M(10));

 1  
/ \

 1  3  
/ \/ \

 1  3  5  
/ \/ \/ \

 1  3  5  7  9  
/ \/ \/ \/ \/ \

C # 6, 95 byte

n=>{var o="";int i=1;for(;i<=n;i+=2)o+=$" {i} ";o+='\n';for(i=1;i<=n;i+=2)o+="/ \\";return o;};

Lambda đầy đủ:

Func<int, string> a = n=>
{
    var o="";int i=1;
    for(;i<=n;i+=2)
        o+=$" {i} ";
    o+='\n';
    for(i=1;i<=n;i+=2)
        o+="/ \\";
    return o;
};

CJam, 26 23 byte

Sri,:)2%_S2**N@,"/ \\"*

Kiểm tra nó!

-3 nhờ 8478 (Martin Ender)

Ngôn ngữ nhà sản xuất trò chơi (GM 8.0), 97 byte

m=ceil(argument0/2)e=""for(i=1;i<2*m;i+=2)e+=" "+string(i)+" "return e+"#"+string_repeat("/ \",m)

Cho rằng đầu vào nhiều nhất là 10, chr(48+i)sẽ hoạt động thay thế string(i), mặc dù số lượng byte là như nhau.

Có thể đọc được

m = ceil(argument0/2)
e = ""
for (i = 1; i < 2*m; i += 2 )
  e += " " + string(i) + " "
return e + "#" + string_repeat("/ \", m)

Bình thường, 24 22 byte

K-SQyMS5+dj*2dK*lK"/ \

Cảm ơn 42545 (ETHproductions) cho -1 byte

Phiên dịch trực tuyến

11 trường hợp kiểm tra

> <> (Cá) 52 63 62 byte

<v!?:-1:!?-1%2:
 >~la}}" "72.
v!?-2lno<o"  "
o
>:?!;"\ /"ooo1-

Hãy thử trực tuyến!

Để sử dụng chỉ cần đặt ntrên ngăn xếp và đi bạn đi!

Phần lớn điều này được lấy từ câu trả lời của @ Teal-Pelican :).

Chỉnh sửa: Đầu ra thực sự không được căn chỉnh chính xác trong khi gửi> <>! Đang sửa chữa ...

Edit2: Tôi đã phải hy sinh một số byte, nhưng hiện tại đầu ra thực sự chính xác.

Edit3: Không có nhiều niềm vui với \ /gương và tôi tiết kiệm 1 byte.

Đầu ra:

 1  3  5  7  9
/ \/ \/ \/ \/ \

C, 100 79 77 byte

#define P(s)for(i=0;i++<n;printf(s,i++));puts("");
i;f(n){P(" %d ")P("/ \\")}

R, 70 69 68 58 byte

cat(paste("",z<-seq(,scan(),2)),"\n");for(i in z)cat("/ \\")

3:
#>  1  3 
#> / \/ \

10:
#>  1  3  5  7  9 
#> / \/ \/ \/ \/ \

Bash, 64, 59, 57, 51, 49, 48, 45 byte

CHỈNH SỬA:

• trừ 3 byte (sử dụng $ 1 thay vì STDIN)
• thêm một byte bằng cách thay thế -s ""bằng-s\
• trừ 2 byte bằng cách thay thế printf bằng seq -f (Cảm ơn @Adam!)
• tái cấu trúc thành tập lệnh thay vì chức năng (để đánh bại > <> )
• loại bỏ không gian thừa
• tối ưu hóa biểu thức sed một chút

Chơi gôn

Chunk (45 byte):

seq -f" %g " -s\  1 2 $1|sed 'p;s| . |/ \\|g'

Hàm (phiên bản gốc) (57 byte):

M() { printf " %s %.0s" `seq 1 $1`|sed 'p;s| . |/ \\|g';}

Kiểm tra

--- mountains.sh ----
#!/bin/bash
seq -f" %g " -s\  1 2 $1|sed 'p;s| . |/ \\|g'

>./mountains.sh 10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

>M 10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

Befunge 93 , 64 byte

Hãy thử trực tuyến!

 &61p1   v+2,,,"/ \"
_v#!`" ":<+2.," ":
 <^p00p10"|<"
@ >91+,$1v

Ruby 82 60 byte

Giải pháp Ruby nhanh và bẩn chắc chắn có thể được tối ưu hóa tốt hơn nếu tôi tốt hơn với Ruby

puts "",1.step($*[0].to_i,2).map{|x|$><<" #{x} ";"/ \\"}*""

Cách sử dụng: prog.rb 10
Kết quả:

 1  3  5  7  9
/ \/ \/ \/ \/ \

chỉnh sửa: nhiều chỉnh sửa và tối ưu hóa bởi @Manatwork!

JavaScript (ES6), 66 64 byte

n=>(f=n=>n?f(n-1)+(n%2?n+s:s):s=" ")(n)+`
`+"/ \\".repeat(++n/2)

Đệ quy xây dựng dòng đầu tiên, sau đó nối thêm dòng thứ hai. Dòng đầu tiên được xây dựng với sự quan sát rằng nó chỉ đơn giản là phạm vi [0 ... n] với mỗi mục n được chuyển thành một khoảng trắng nếu chẵn hoặc n nối với một khoảng trắng nếu lẻ.

Python 2, 60 byte

Đã lưu 6 byte nhờ @Kade!

lambda s:" "+"  ".join(`range(s+1)`[4::6])+"\n"+-~s/2*"/ \\"

Mẻ, 107 byte

@set s=
@set t=
@for /l %%i in (1,2,%1)do @call set s=%%s%%  %%i&call set t=%%t%%/ \
@echo%s%
@echo %t%

Scala, 99 95 byte

(? :Int)=>for(i<-0 to 1)println(1 to ?filter(c=>c%2>0)map(c=>if(i<1)s" $c "else"/ \\")mkString)

Bị đánh cắp

(? :Int) => 
    for (i<-0 to 1)
        println(
            1 to ?filter(c=>c%2>0)
                  map(c=>if(i<1)s" $c "else"/ \\")
                  mkString
        )

Ruby, 48 byte

->x{" 1  3  5  7  9 "[0..3*x-=x/2]+?\n+"/ \\"*x}

Octave, 45 byte

f=@(n)reshape(sprintf(' /%d \',1:2:n),2,[]);

Kiểm tra:
f (8)

 1  3  5  7
/ \/ \/ \/ \

QBIC , 35 byte

:[1,a,2|X=X+!b$+@ | Y=Y+@/ \|]?X ?Y

Giải trình:

:           gets a CMD line param as INT 'a'
[1,a,2|     FOR b = 1 to a STEP 2
X=X+!b$+@ | Add to X$ the counter of our FOR loop and a trailing space
            Leading space is provided by the cast-to-string function.
Y=Y+@/ \|   Add to Y$ the mountain.
]           Close the first possible language construct (IF, DO or FOR). In this case: NEXT
?X ?Y       Print X$, Print Y$. The space adds a newline in the resulting QBASIC.

Kitanai , 140 byte

$0[0]$1[int(input":")]$2[""]$3[""]$0#?(mod@2)($2[add(add(@" ")(string($0@)))"  "]
$3[add@"/ \"])?(neq@($1@))([add@1]&1)print($2@)print($3@)%

Perl, 46 + 2 ( -plcờ) = 48 byte

@_=map$_%2?$_:"",0..$_;$_="@_$/"."/ \\"x(@_/2)

Sử dụng:

perl -ple '@_=map$_%2?$_:"",0..$_;$_="@_$/"."/ \\"x(@_/2)' <<< 7    

Hoặc 52 byte:

@_=map$_%2?$_:"",0..pop;print"@_$/","/ \\"x(@_/2),$/

Sử dụng:

perl -e '@_=map$_%2?$_:"",0..pop;print"@_$/","/ \\"x(@_/2),$/' 7