Thách thức là liệt kê tất cả các phân vùng được sắp xếp (thành phần (tổ hợp)) của một số nguyên dương cho trước n. Đây là danh sách các số từ 1đến ntổng của nó n. Ví dụ, đầu vào đã cho n = 4, kết quả sẽ là:

4
1, 3
3, 1
2, 2
2, 1, 1
1, 2, 1
1, 1, 2
1, 1, 1, 1

Kết quả có thể theo bất kỳ thứ tự nào, nhưng phải chứa mỗi phân vùng được đặt hàng một lần. Điều này có nghĩa rằng cho n = 4, [1, 1, 2], [1, 2, 1]và [2, 1, 1]phải tất cả là một phần của kết quả.

Đây là mã JavaScript của riêng tôi để đạt được điều này:

function range(n) {
    for (var range = [], i = 0; i < n; range.push(++i));
    return range;
}

function composition(n) {
    return n < 1 ? [[]] : range(n).map(function(i) {
        return composition(n - i).map(function(j) {
            return [i].concat(j);
        });
    }).reduce(function(a, b) {
        return a.concat(b);
    });
}

Đã chơi gôn, ES6 ( 169 167 119 109 105 89 85 byte ):

n=>n?[].concat(...[...Array(n)].map((x,i)=>i+1).map(b=>m(n-b).map(a=>[b,...a]))):[[]]

Bình thường, 7 6 byte

Giải pháp 7 byte:

Pyth có một phân vùng số nguyên dựng sẵn ./, vì vậy 5 trong số 7 byte đang nhận được thứ tự.

{s.pM./

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

Giải trình:

     ./  Integer partition (sorted by default)
  .pM    get all the orderings of each of the partitions as a nested list of lists of orderings
 s       Flatten by one layer
{        Remove duplicates

Giải pháp 6 byte:

Nếu bạn có một danh sách, ./sẽ tính toán với thứ tự; tất cả những gì còn lại là làm cho các số danh sách một lần nữa.

lMM./m

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

Giải trình:

     m  Get lists by gathering a list of [0, 1,...input] (I could use U as well)

   ./   Partition with orderings
 MM     Map an operation across each of the orderings lists of elements
l       where that operation is the length of the sublists

Haskell, 37 byte

f 0=[[]]
f n=[a:x|a<-[1..n],x<-f$n-a]

xnor lưu hai byte.

Python, 56 byte

f=lambda n:[x+[n-i]for i in range(n)for x in f(i)]or[[]]

Một giải pháp đệ quy: Các phân vùng ra lệnh của nmột phân vùng của một số nhỏ hơn ivới 0<=i<n, tiếp theo là thời gian còn lại n-ilà yếu tố cuối cùng. Đối với một trường hợp cơ sở, n=0chỉ có phân vùng trống.

Python 2, 61 byte

f=lambda n,s='1,':1/n*[eval(s)]or f(n-1,'1+'+s)+f(n-1,'1,'+s)

Đây không phải là ngắn nhất, nhưng tôi thực sự thích phương pháp này vì nó rất kỳ lạ.

Đệ quy tạo và đánh giá các 2**(n-1)chuỗi, như

1+1+1+1,
1,1+1+1,
1+1,1+1,
1,1,1+1,
1+1+1,1,
1,1+1,1,
1+1,1,1,
1,1,1,1,

cho n=4. Các chuỗi này đánh giá các bộ dữ liệu đại diện cho tất cả các phân vùng. Giữa hai số 1 bất kỳ là a +, nối chúng thành một số duy nhất hoặc a ,, tách các phần liền kề.

JavaScript (Firefox 30-57), 63 byte

f=n=>n?[for(i of Array(n).keys())for(a of f(i))[n-i,...a]]:[[]]

Toán học, 40 byte

Join@@Permutations/@IntegerPartitions@#&

Mathicala được tích hợp sẵn cho các phân vùng số nguyên không cung cấp cho tất cả các phân vùng được sắp xếp , vì vậy chúng tôi phải tạo ra tất cả các hoán vị có thể có của mỗi phân vùng đó, và sau đó làm phẳng kết quả.

CJam , 17 14 byte

ri"X)"m*{~]p}/

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

Giải trình

Tôi biết tôi đã nói rằng việc sử dụng sản phẩm của Cartesian lâu hơn, nhưng cuối cùng tôi đã tìm ra cách sử dụng nó hiệu quả hơn. Tôi nghĩ rằng cả hai cách tiếp cận đều thú vị theo cách riêng của họ, vì vậy tôi sẽ đặt chúng vào các bài viết riêng biệt.

Điều này vẫn dựa trên ý tưởng rằng, chúng ta có thể chọn nthời gian giữa việc nối thêm một 1phân vùng hiện tại hoặc để tăng phần tử cuối cùng của phân vùng hiện tại. Trong giải pháp này, chúng tôi thực hiện điều này bằng cách tạo 2 ^n-1 chương trình khác nhau tương ứng với các lựa chọn khác nhau này.

ri      e# Read input and convert to integer N.
        e# Decrement.
"X)"m*  e# Get all strings of length N which consist of 'X' and ')'. If
        e# we treat these strings as CJam code then 'X' pushes a 1 and ')'
        e# increments the top of the stack.
        e# Note that some of these strings will begin with an increment that
        e# doesn't have anything on the stack to work with. This will result in
        e# an error and terminate the program. Luckily, the programs are ordered
        e# such that all programs starting with 'X' are first in the list, so
        e# we get to print all the 2^(N-1) permutations before erroring out.
{       e# For each of these programs (well for the first half of them)...
  ~     e#   Evaluate the string as CJam code. This leaves the partition as
        e#   individual integers on the stack.
  ]p    e#   Wrap the stack in a list and pretty-print it.
}/

Thạch , 7 6 byte

-1 byte nhờ @Dennis (chuyển đổi từ unary ḅ1, thay vì tổng cho từng byte S€€)

1ẋŒṖḅ1

Dùng thử

Làm sao?

1ẋŒṖḅ1 - Main link: n          e.g. 4
1ẋ     - repeat 1 n times          [1,1,1,1]
  ŒṖ   - partitions of a list     [[[1],[1],[1],[1]], [[1],[1],[1,1]], [[1],[1,1],[1]],
                                   [[1],[1,1,1]],     [[1,1],[1],[1]], [[1,1],[1,1]],
                                   [[1,1,1],[1]],     [[1,1,1,1]]]
    ḅ1 - from base 1 (vectorises)  [[1,1,1,1],        [1,1,2],         [1,2,1],
                                   [1,3],             [2,1,1],         [2,2],
                                   [3,1],             [4]]

Bash thuần khiết, 51

Đây là một câu trả lời tuyệt vời của @ xnor , sử dụng nhiều cấp độ mở rộng bash để đạt được kết quả mong muốn:

a=$[10**($1-1)]
eval echo \$[${a//0/{+,']\ $[}1'}],

Ideone.

• Dòng đầu tiên chỉ đơn giản là một mở rộng số học để tạo ra một biến $achứa 1các n-1số 0 theo sau .
• Việc mở rộng đầu tiên ${a//0/{+,']\ $[}1'}thay thế từng 0ở $avới bản sao của chuỗi {+,']\ $[}1'. Do đó n = 4 ta được chuỗi1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1'
• Điều này có tiền tố $[và tiền tố với ],để cung cấp$[1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1]
• Đây là một mở rộng cú đúp mở rộng đến $[1+1+1+1], $[1+1+1] 1, $[1+1] $[1+1], $[1+1] 1 1,...
• Điều này cuối cùng được mở rộng một cách hợp lý để đưa ra kết quả cần thiết.

Sử dụng cẩn thận các trích dẫn, dấu gạch chéo ngược và evalđảm bảo rằng các mở rộng xảy ra theo đúng thứ tự.

Ruby, 61 byte

f=->n{n<1?[[]]:(1..n).map{|i|f[n-i].map{|x|x<<i}}.flatten(1)}

vô dụng

f=->n{
  n < 1 ?
    [[]]
  :
    (1..n).map { |i|
      f[n-i].map { |x|
        x << i
      }
    }.flatten(1)
}

sử dụng

p f[4]
# => [[1, 1, 1, 1], [1, 1, 2], [1, 2, 1], [1, 3], [2, 1, 1], [2, 2], [3, 1], [4]]

Brachylog , 20 byte

~lL#++?,L:=f:{:0x}ad

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

Giải trình

Đây là một tình huống mà bạn sẽ nghĩ rằng các ngôn ngữ khai báo sẽ làm tốt, nhưng vì quá tải +và khác biệt trong việc viết một vị từ tổng hợp mà truyền các ràng buộc đúng, chúng không làm được.

~lL                     L is a list of length Input
  L#+                   L is a list of non-negative integers
  L  +?,                The sum of the elements of L results in the Input
        L:=f            Find all values for the elements of L which satisfy those constraints
            :{:0x}a     Remove all 0s from each sublist of the result of Findall
                   d    Remove all duplicate sublists

CJam , 19 byte

Lari{_1af.+1@f+|}*p

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

Giải trình

CJam không có tổ hợp hữu ích tích hợp sẵn cho các phân vùng số nguyên. Vì vậy, chúng tôi sẽ làm điều này bằng tay. Để tìm tất cả các phân vùng được sắp xếp của một số nguyên n, chúng ta có thể xem danh sách các phân vùng nvà xem xét mọi cách có thể để chèn dấu phân cách. Sau đó, chúng tôi sẽ tổng hợp 1s trong mỗi phần. Ví dụ cho n = 3:

1 1 1 => 3
1 1|1 => 2|1
1|1 1 => 1|2
1|1|1 => 1|1|1

Tôi đã thử sử dụng một sản phẩm của Cartesian để tạo ra tất cả các dấu phân cách này, nhưng kết quả là 21 byte. Thay vào đó, tôi đã quay lại kỹ thuật cũ này để tạo ra các bộ năng lượng (điều này dựa trên câu trả lời cũ của Dennis nhưng tôi không thể tìm thấy nó ngay bây giờ). Ý tưởng là thế này: để tạo tất cả các phân vùng, chúng ta có thể bắt đầu từ một danh sách trống. Sau đó, nlần chúng ta có thể đưa ra quyết định nhị phân: hoặc chúng ta nối thêm một 1(tương ứng với dấu phân cách trong ví dụ trên) hoặc chúng ta tăng giá trị cuối cùng của danh sách (tương ứng với việc không có dấu phân cách). Để tạo tất cả các phân vùng, chúng tôi chỉ cần thực hiện cả hai thao tác ở mỗi bước và giữ tất cả các đầu ra có thể cho bước tiếp theo. Nó chỉ ra rằng trong CJam, việc chuẩn bị và gia tăng phần tử đầu tiên ngắn hơn, nhưng nguyên tắc vẫn giữ nguyên:

La       e# Push [[]] onto the stack. The outer list will be the list of
         e# all possible partitions at the current iteration, and we initialise
         e# it to one empty partition (basically all partitions of 0).
ri       e# Read input and convert to integer N.
{        e# Repeat this N times...
  _      e#   Duplicate the list of partitions of i-1.
  1af.+  e#   Increment the first element in each of these. This is done
         e#   by performing a pairwise addition between the partition and [1].
         e#   There is the catch that in the first iteration this will turn
         e#   the empty array into [1], so it's equivalent to the next step.
  1@f+   e#   Pull up the other copy of the list of partitions of i-1 and
         e#   prepend a 1 to each of them.
  |      e#   Set union. This gets rid of the duplicate result from the first
         e#   iteration (in all other iterations this is equivalent to concatenating
         e#   the two lists).
         e#   Voilà, a list of all partitions of i.
}*
p        e# Pretty-print the result.

T-SQL, 203 byte

Chơi gôn

USE master
DECLARE @ INT=12

;WITH z as( SELECT top(@)cast(number+1as varchar(max))a FROM spt_values WHERE'P'=type),c as(SELECT a*1a,a b FROM z UNION ALL SELECT c.a+z.a,b+','+z.a FROM c,z WHERE c.a+z.a*1<=@)SELECT b FROM c WHERE a=@

Ung dung:

USE master --needed to make sure it is executed from the correct database
DECLARE @ INT=12

;WITH z as
(
  SELECT top(@)cast(number+1as varchar(max))a
  FROM spt_values
  WHERE'P'=type
),c as
(
  SELECT a*1a,a b
  FROM z
  UNION ALL
  SELECT c.a+z.a,b+','+z.a
  FROM c,z
  WHERE c.a+z.a*1<=@
)
SELECT b 
FROM c
WHERE a=@

Vĩ cầm

Toán học 10.0, 44 byte

Một nỗ lực mà không sử dụng các nội dung liên quan đến phân vùng. Từ mỗi phân vùng có thứ tự kích thước k , hai phân vùng kế tiếp của k + 1 được tạo ra: một bằng cách thêm trước 1 và phân vùng kia bằng cách tăng giá trị đầu tiên.

Nest[##&[{1,##},{#+1,##2}]&@@@#&,{{1}},#-1]&

Một cách hài hước hơn, nhưng đáng buồn hơn là 2 byte cách thực hiện cùng một ý tưởng:

#@{1}&/@Tuples[Prepend[1]@*MapAt[#+1&,1],#-1]&

05AB1E , 14 12 byte

Đã lưu 2 byte nhờ Adnan

>G¹LNãvyO¹Q—

Giải trình

>G              # for N in range(1..input)
  ¹L            # range(1, input)
    Nã          # cartesian product with N (all combinations of length N)
      v         # for each resulting list
       yO¹Q—    # if it's sum equals the input print it

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

Giải pháp tương ứng là 2 byte ngắn hơn trong 2sable .

2sable , 10 byte

>GLNãvyOQ—

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

Haskell, 41 byte

f 1=[[1]]
f n=do a:b<-f$n-1;[1:a:b,a+1:b]

Không phải là giải pháp Haskell ngắn nhất, nhưng tôi thích rằng nó không sử dụng [..]phạm vi. Thay vào đó, nó tính toán đệ quy các phân vùng nlà phân vùng n-1với 1 mới khi bắt đầu hoặc giá trị đầu tiên cao hơn. Điều này làm cho rõ ràng tại sao có 2^(n-1)chúng.

Toán học, 53 byte

Không đánh bại câu trả lời của Martin Ender, sử dụng IntegerPartitionschức năng tích hợp sẵn (và tích hợp hoàn toàn tốt đối với tôi). (Nó cũng không đánh bại câu trả lời của feerum, điều mà tôi đã không thấy cho đến khi quá muộn.) Nhưng tôi muốn thực hành một chức năng đệ quy golf.

If[#<1,{{}},Join@@Table[#~Append~j&/@#0[#-j],{j,#}]]&

Đệ quy tạo ra tất cả các tác phẩm, bằng cách tạo ra tất cả các số chính thức có thể jvà sau đó tự xưng là trên #-jnơi #là đầu vào.

Võng mạc , 32 byte

Số lượng byte giả định mã hóa ISO 8859-1.

.+
$*
+%1`1
!$'¶$`,!
!+
$.&
A`^,

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

Giải trình

Điều này hoạt động tương tự như câu trả lời của tôi . Chúng tôi đi qua một danh sách Nvà tại mỗi vị trí, chúng tôi lấy cả hai nhánh của quyết định nhị phân a) tăng giá trị cuối cùng hoặc b) bắt đầu một giá trị mới ở 1.

Giai đoạn 1

.+
$*

Chuyển đổi đầu vào thành unary.

Giai đoạn 2

+%1`1
!$'¶$`,!

Việc báo +cho Retina thực hiện giai đoạn này trong một vòng lặp cho đến khi đầu ra dừng thay đổi. Nó %bảo nó chia đầu vào thành các dòng trước khi áp dụng giai đoạn và nối chúng lại với nhau sau đó. Bằng cách đặt %sau +, Retina chia tách và nối lại sau mỗi lần lặp. Một lần lặp lại của giai đoạn làm cho một trong những quyết định mà tôi đã đề cập và do đó phân chia bộ phân vùng hiện tại.

Làm thế nào nó thực sự hoạt động là nó phù hợp với một 1(nhưng chỉ là người đầu tiên như được chỉ ra bởi 1ở phía trước của backtick), và thay thế nó bằng !(mà chúng tôi sẽ sử dụng như là chữ số unary sản lượng của chúng tôi), tiếp theo là phần còn lại 1của trên hàng này (giá trị này tăng giá trị cuối cùng). Sau đó, trên một dòng khác ( ¶) nó in tiền tố của dòng hiện tại, theo sau ,!, nó chèn một dấu phân cách và sau đó bắt đầu giá trị tiếp theo tại1 .

Giai đoạn 3

!+
$.&

Điều này chuyển đổi các hoạt động của ! số nguyên thập phân bằng cách thay thế chúng bằng chiều dài của chúng.

Giai đoạn 4

A`^,

Và cuối cùng, chúng tôi nhận thấy rằng chúng tôi đã tạo ra gấp đôi số dòng chúng tôi muốn và một nửa trong số chúng bắt đầu bằng một ,(những nơi ban đầu chúng tôi đưa ra quyết định chia tách, mặc dù sau đó vẫn chưa có gì để chia tách). Do đó, chúng tôi loại bỏ tất cả các dòng bắt đầu bằng a ,.

Perl, 44 byte

Bao gồm +3 cho -n(sử dụng mã $'và $0vì vậy nó không thể chạy dưới dạng-e dòng lệnh)

Cung cấp số cho phân vùng trên STDIN:

partitions.pl <<< 4

partitions.pl

#!/usr/bin/perl -n
$_=$&-$_.",$_$'",do$0for/\d+/..$&-1;print

Nếu bạn không quan tâm đến các khoảng trắng thừa ở cuối dòng và một dòng mới bổ sung thì giải pháp 42 byte này cũng hoạt động (chạy như perl -M5.010 partitions.pl):

#!/usr/bin/perl -n
$_=$`-$_." $_ $'",do$0for/\s/..$_-1;say

Julia, 113 byte

f(N)=unique(reduce(vcat,(map(x->[permutations(x)...],[vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N]))))

Giải pháp không đệ quy

Giải thích:

1. [vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N] xây dựng một tập hợp các danh sách tổng hợp thành N, có hoán vị sẽ giống với giải pháp (ví dụ: N = 4: [[1,1,1,1], [1,1,2], [1,3], [4 ]])
2. map(x->[permutations(x)...],) Tính toán tất cả các hoán vị
3. reduce(vcat,) kết hợp chúng thành một danh sách các danh sách
4. unique() bộ lọc trùng lặp

MATL , 15 byte

:"G:@Z^t!XsG=Y)

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

Giải trình

Với đầu vào n, điều này sẽ tính toán sức mạnh của Cartesian với số mũ tăng dần ktừ 1đến n; và với mỗi số mũ kchọn các bộ dữ liệu có tổng bằng với đầu vào.

:       % Take input n implicitly and push range [1 2 ... n]
"       % For each k in that range
  G:    %   Push [1 2 ... n] again
  @     %   Push k
  Z^    %   Cartesian power. Gives 2D array, say A, with each k-tuple in a row.
  t     %   Duplicate
  !     %   Transpose
  Xs    %   Sum of each column. Gives a row vector
  G=    %   True for entries that equal the input
  Y)    %   Use as logical vector into the rows of array A
        % End implicitly
        % Display stack implicitly

Lua 214 203 182 byte

function g(m, l, n,c)for i=1,m do if i+n < m then l[#l+1]=i;g(m,l,n+i,c+1)elseif i+n == m then l[#l+1]=i;print(unpack(l))end end for k=c,#l do l[k]=nil end end g(io.read()*1,{},0,0)

Phiên bản đã được giải quyết.

function g(m, l, n,c)
    for i=1,m do 
        if i+n < m then 
            l[#l+1]=i
            g(m,l,n+i,c+1)
        elseif i+n == m then 
            l[#l+1]=i
            print(unpack(l))
        end 
    end 
    for k=c,#l do 
        l[k]=nil 
    end 
end 
g(io.read()*1,{},0,0)

Tìm thấy một khoảng trắng đi lạc và loại bỏ một biến không cần thiết để an toàn 11 byte. khi nó bật ra, table.insert () là byte không hiệu quả

PHP, 125 byte

for($i=$n=$argv[1];$i<=str_repeat(1,$n);$i++)if(array_sum($a=str_split($i))==$n&!strpos($i,"0"))$r[]=$a;echo json_encode($r);

-4 byte print_r($r);thay vì echo json_encode($r);cho đầu ra

một giải pháp đệ quy với 250 byte

function f($n){global$a;foreach($a as$x)foreach(range(1,$n)as$y)$a[]=array_merge((array)$x,[$y]);if(--$n)f($n);}$a=range(1,$w=$argv[1]);f($w-1);foreach($a as$z)if(array_sum((array)$z)==$w)$c[join("-",(array)$z)]=$z;echo json_encode(array_values($c));

Prolog, 81 byte + 6 byte để gọi

L*L.
[H|T]*L:-H>1,M is H-1,[M,1|T]*L.
[H,K|T]*L:-H>1,M is H-1,N is K+1,[M,N|T]*L.

Hãy thử trực tuyến!
Gọi với [4]*L., lặp lại với ;cho đến khi tất cả các giải pháp đã được trình bày.

Ngoài ra, nếu nhấn liên tục ;không ổn (hoặc nên thêm vào số byte), hãy gọi bagof(L,[4]*L,M).thêm 17 byte cho cuộc gọi.

J , 30 26 byte

#&1<@(+/;.1)~2#:@(+i.)@^<:

Hoạt động bằng cách tách danh sách unary n bằng cách sử dụng các giá trị nhị phân của 2 ⁿ .

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

Giải trình

#&1<@(+/;.1)~2#:@(+i.)@^<:  Input: n
                        <:  Decrement n
             2         ^    Compute 2^(n-1)
                 (   )@     Operate on that
                   i.         Make the range [0, 1, ..., 2^(n-1)-1]
                  +           Add 2^(n-1) to each in that range
              #:@           Convert each in that range to binary
#&1                         Make n copies of 1 (n in unary)
     (     )~               Operate over each row on RHS and unary n on LHS
        ;.1                   Chop unary n starting at each 1
      +/                        Reduce by addition on each chop
   <@                           Box the sums of each chop

Trên thực tế, 17 16 byte

Câu trả lời này một phần dựa trên câu trả lời MATL của Luis Mendo . Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

;╗R`╜R∙i`M`Σ╜=`░

Ungolfing

         Implicit input n.
;╗       Duplicate n and save a copy of n to register 0.
R        Take the range of [1..n].
`...`M   Map the following function over the range. Variable k.
  ╛R       Push n from register 0 and take the range [1..n] again.
  ∙        Take the k-th Cartesian power of the range.
  i        Flatten that product.
`...`░   Push values of the previous map where the following function returns a truthy value.
          Variable L.
  Σ        Push sum(L).
  ╜        Push n from register 0.
  =        Check if sum(L) == n.
         Implicit return.

Trên thực tế, 17 16 15 byte

Đây là một ngã ba thú vị của câu trả lời CJam của Martin Ender ( câu trả lời với sản phẩm của Cartesian), với sự khác biệt trong cách thực hiện mà tôi nghĩ là thú vị. Khi một trong các chuỗi của Martin bắt đầu với số gia tăng, các lỗi sẽ ngăn không cho chuỗi đó được đánh giá. Trong thực tế, lỗi được loại bỏ và chuỗi được đánh giá bằng mọi cách. Điều này kết thúc việc đưa ra các tác phẩm của mỗi ktrong phạm vi [1..n].

Thay vì cố gắng loại bỏ các tác phẩm bổ sung, tôi đã lấy n-1sức mạnh của Cartesian "1u"nối thêm vào "1"đầu mỗi chuỗi. Thủ thuật này chỉ cung cấp cho các thành phần của n. Thật không may, nó dài hơn câu trả lời của Martin.

Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

D"1u"∙`1@Σ£ƒk`M

Ungolfing

         Implicit input n.
D        Decrement n.
"1u"∙    Take the (n-1)th Cartesian power of the string "1u".
          In Actually, 1 pushes 1 to the stack and u is increment.
`...`M   Map the following function over the Cartesian power. Variable s.
  1@       Push a 1 to be used later.
  Σ        Summing a list of chars joins the chars into one string.
  £ƒ       Turn s into a function and call it immediately on the 1 in the stack.
  k        Take the whole stack and wrap in a list. This is a composition of n.
         Implicit return.