ความท้าทายคือการแสดงรายการพาร์ทิชันทั้งหมดที่สั่งซื้อ (องค์ประกอบ (combinatorics)) nของจำนวนเต็มบวกให้ เหล่านี้เป็นรายการของตัวเลขจาก1การที่มีผลรวมเป็นn nตัวอย่างเช่นอินพุตที่กำหนดn = 4ผลลัพธ์ควรเป็น:

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

ผลลัพธ์สามารถอยู่ในลำดับใดก็ได้ แต่ต้องมีพาร์ติชันที่สั่งซื้อแต่ละครั้ง ซึ่งหมายความว่าสำหรับn = 4, [1, 1, 2], [1, 2, 1]และ[2, 1, 1]ทุกคนจะต้องเป็นส่วนหนึ่งของผล

นี่คือรหัส JavaScript ของฉันเองซึ่งประสบความสำเร็จในสิ่งนี้:

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

Golfed, ES6 ( 169 167 119 109 105 89 85 ไบต์ ):

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

Pyth, 7 6 ไบต์

โซลูชั่น 7 ไบต์:

Pyth มีพาร์ติชั่นจำนวนเต็มในตัว./ดังนั้น 5 ใน 7 ไบต์จึงได้ลำดับ

{s.pM./

ลองออนไลน์!

คำอธิบาย:

     ./  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

โซลูชั่น 6 ไบต์:

หากคุณมีรายการ./จะคำนวณด้วย orderings ทั้งหมดที่เหลืออยู่คือการทำให้หมายเลขรายการอีกครั้ง

lMM./m

ลองออนไลน์!

คำอธิบาย:

     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 ไบต์

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

xnor บันทึกสองไบต์

Python ขนาด 56 ไบต์

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

วิธีการแก้ปัญหา recursive: สั่งของพาร์ทิชันnเป็นพาร์ติชันของบางส่วนที่มีขนาดเล็กiด้วย0<=i<nตามด้วยส่วนที่เหลือn-iเป็นองค์ประกอบที่ผ่านมา สำหรับกรณีฐานn=0มีพาร์ติชันที่ว่างเปล่าเท่านั้น

Python 2, 61 ไบต์

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

นี่ไม่ใช่วิธีที่สั้นที่สุด แต่ฉันชอบวิธีนี้มากเพราะมันแปลกมาก

สร้างและประเมิน2**(n-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,

n=4สำหรับ สตริงเหล่านี้ประเมินค่าเป็น tuples ที่แสดงถึงพาร์ติชันทั้งหมด ระหว่างใด ๆ ของสอง 1 เป็นอย่างใดอย่างหนึ่ง+, เข้าร่วมพวกเขาเป็นตัวเลขเดียวหรือ,แยกส่วนที่อยู่ติดกัน

JavaScript (Firefox 30-57), 63 ไบต์

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

Mathematica ขนาด 40 ไบต์

Join@@Permutations/@IntegerPartitions@#&

Mathematica ในตัวสำหรับพาร์ติชั่นจำนวนเต็มไม่ได้ให้พาร์ติชั่นสั่งทั้งหมดดังนั้นเราต้องสร้างการเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมดของแต่ละพาร์ติชั่นแล้วเรียบผลลัพธ์

CJam , 17 14 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ฉันรู้ว่าฉันพูดว่าการใช้ผลิตภัณฑ์คาร์ทีเซียนนั้นใช้เวลานาน แต่ฉันก็พบวิธีที่จะใช้งานได้อย่างมีประสิทธิภาพมากขึ้น ฉันคิดว่าทั้งสองวิธีมีความน่าสนใจในสิทธิของตนเองดังนั้นฉันจึงวางมันลงในโพสต์แยก

สิ่งนี้ยังคงขึ้นอยู่กับแนวคิดที่ว่าเราสามารถเลือกnเวลาระหว่างการต่อท้าย1พาร์ติชันปัจจุบันหรือเพิ่มองค์ประกอบสุดท้ายของพาร์ติชันปัจจุบัน ในการแก้ปัญหานี้เราทำสิ่งนี้โดยการสร้างโปรแกรมที่แตกต่างกัน2 ^n-1ซึ่งสอดคล้องกับตัวเลือกที่แตกต่างกันเหล่านี้

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.
}/

เยลลี่ , 7 6 ไบต์

-1 ไบต์ขอบคุณ @Dennis (แปลงจาก unary ḅ1มากกว่าผลรวมสำหรับแต่ละรายการS€€)

1ẋŒṖḅ1

TryItOnline

อย่างไร?

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

Pure Bash, 51

นี่คือพอร์ตของคำตอบที่ยอดเยี่ยมของ@ xnorโดยใช้การขยาย bash หลายระดับเพื่อให้ได้ผลลัพธ์ตามที่ต้องการ:

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

Ideone

• บรรทัดแรกเป็นเพียงการขยายเลขคณิตในการสร้างตัวแปร$aที่มีศูนย์1ตามมาด้วยn-1
• การขยายตัวครั้งแรก${a//0/{+,']\ $[}1'}แทนที่แต่ละ0ในกับสำเนาของสตริง$a {+,']\ $[}1'ดังนั้น n = 4 เราจึงได้สตริง1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1'
• นี่คือคำนำหน้าด้วย$[และ postfixed ด้วย],เพื่อให้$[1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1]
• นี่คือการขยายรั้งที่ขยายไป $[1+1+1+1], $[1+1+1] 1, $[1+1] $[1+1], $[1+1] 1 1,...
• นี่คือการขยายแบบเลขคณิตในที่สุดเพื่อให้ผลลัพธ์ที่ต้องการ

ใช้เครื่องหมายคำพูดอย่างระมัดระวังแบคสแลชหนีและevalทำให้แน่ใจว่าการขยายเกิดขึ้นในลำดับที่ถูกต้อง

Ruby, 61 ไบต์

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

ungolfed

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

การใช้

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 ไบต์

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

ลองออนไลน์!

คำอธิบาย

นี่เป็นสถานการณ์ที่คุณคิดว่าภาษาที่ประกาศออกมาจะทำได้ดี แต่เนื่องจากการใช้งานเกินพิกัด+และการเขียนคำกริยาสรุปที่แพร่กระจายข้อ จำกัด ได้อย่างถูกต้องจึงไม่ทำเช่นนั้น

~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 ไบต์

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

ลองออนไลน์!

คำอธิบาย

CJam ไม่มี combinatorics ที่มีประโยชน์ในตัวสำหรับพาร์ติชันจำนวนเต็ม ดังนั้นเราจะทำสิ่งนี้ด้วยตนเอง ในการค้นหาพาร์ติชั่นที่สั่งซื้อทั้งหมดของจำนวนเต็มnเราสามารถดูรายการพาร์ทิชั่นnและพิจารณาทุกวิธีที่เป็นไปได้ในการแทรกตัวคั่น จากนั้นเราจะหาผลรวม1ในแต่ละส่วน ตัวอย่างสำหรับn = 3:

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

ฉันลองใช้ผลิตภัณฑ์คาร์ทีเซียนเพื่อสร้างตัวคั่นเหล่านี้ทั้งหมด แต่นั่นสิ้นสุดที่ 21 ไบต์ แต่ฉันกลับไปใช้เทคนิคเก่านี้เพื่อสร้างชุดพลัง (ขึ้นอยู่กับคำตอบเก่าของเดนนิส แต่ตอนนี้ฉันหามันไม่พบ) แนวคิดคือ: เพื่อสร้างพาร์ติชันทั้งหมดที่เราสามารถเริ่มต้นจากรายการที่ว่างเปล่า จากนั้นnเวลาที่เราสามารถทำการตัดสินใจแบบไบนารี: ทั้งเราผนวก a 1(สอดคล้องกับตัวคั่นในตัวอย่างข้างต้น) หรือเราเพิ่มค่าสุดท้ายของรายการ (สอดคล้องกับการไม่มีตัวคั่น) ในการสร้างพาร์ติชันทั้งหมดเราเพียงดำเนินการทั้งสองอย่างในแต่ละขั้นตอนและเก็บเอาท์พุทที่เป็นไปได้ทั้งหมดสำหรับขั้นตอนถัดไป ปรากฎว่าใน CJam การเตรียมและการเพิ่มองค์ประกอบแรกจะสั้นกว่า แต่หลักการยังคงเหมือนเดิม:

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 ไบต์

แข็งแรงเล่นกอล์ฟ:

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=@

Ungolfed:

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=@

ซอ

Mathematica 10.0, 44 ไบต์

ความพยายามโดยไม่ใช้บิวด์อินที่เกี่ยวข้องกับพาร์ติชัน จากพาร์ติชันที่สั่งซื้อแต่ละขนาดkพาร์ติชันสืบต่อกันสองอันของk + 1จะถูกสร้างขึ้นหนึ่งพาร์ติชันโดยการเพิ่ม 1 และอีกพาร์ติชันโดยการเพิ่มค่าแรก

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

วิธีที่สนุกกว่า แต่เศร้ากว่า 2 ไบต์เมื่อใช้ความคิดเดียวกัน:

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

05AB1E , 14 12 ไบต์

บันทึก 2 ไบต์ต้องขอบคุณAdnan

>G¹LNãvyO¹Q—

คำอธิบาย

>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

ลองออนไลน์!

วิธีการแก้ปัญหาที่สอดคล้องกันคือ 2 ไบต์สั้น2sable

2sable , 10 ไบต์

>GLNãvyOQ—

ลองออนไลน์!

Haskell, 41 ไบต์

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

ไม่ใช่ทางออกที่สั้นที่สุดของ Haskell แต่ฉันชอบที่มันไม่ได้ใช้[..]ช่วง แต่จะคำนวณพาร์ติชันของ recursively nเป็นพาร์ติชันn-1ด้วย 1 ใหม่ที่จุดเริ่มต้นหรือค่าแรกที่สูงกว่า สิ่งนี้ชัดเจนว่าทำไมถึงมี2^(n-1)พวกเขา

Mathematica, 53 ไบต์

ไม่ได้เอาชนะคำตอบของ Martin Ender ซึ่งใช้IntegerPartitionsฟังก์ชันในตัว(และ built-in ก็ดีสำหรับฉัน) (หรือมันจะไม่ชนะคำตอบของ feersum ซึ่งฉันไม่ได้เห็นจนกระทั่งสายเกินไป) แต่ฉันต้องการฝึกฟังก์ชั่นวนซ้ำแบบตีกอล์ฟ

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

สร้างการประพันธ์ซ้ำทั้งหมดโดยการสร้างหมายเลขสุดท้ายที่เป็นไปได้ทั้งหมดjแล้วเรียกตัวเองว่าอยู่#-jที่ไหน#ในการป้อนข้อมูล

เรติน่า 32 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

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

ลองออนไลน์!

คำอธิบาย

นี้ทำงานคล้ายกับฉันคำตอบ CJam เราผ่านรายการNและในแต่ละตำแหน่งเราใช้ทั้งสองสาขาของการตัดสินใจแบบไบนารี a) การเพิ่มค่าสุดท้ายหรือ b) เริ่มต้นค่าใหม่ที่ 1

ด่าน 1

.+
$*

แปลงอินพุตเป็น unary

ด่าน 2

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

+บอก Retina ในการดำเนินการขั้นตอนนี้ในวงจนการส่งออกหยุดการเปลี่ยนแปลง The %บอกให้แบ่งอินพุตเป็นบรรทัดก่อนที่จะใช้เวทีและเข้าร่วมพวกเขากลับมารวมกันในภายหลัง โดยการใส่%หลัง+, Retina แยกและตอบสนองหลังจากการทำซ้ำแต่ละครั้ง การทำซ้ำขั้นตอนหนึ่งครั้งเป็นการตัดสินใจอย่างใดอย่างหนึ่งที่ฉันกล่าวถึง

มันทำงานอย่างไรจริง ๆ แล้วมันตรงกับ1(แต่เพียงอันแรกตามที่ระบุไว้ที่1ด้านหน้าของ backtick) และแทนที่ด้วย!(ซึ่งเราจะใช้เป็นตัวเลขหลักของผลลัพธ์ของเรา) ตามด้วย1s ที่เหลือในแถวนี้ (นี่เป็นการเพิ่มค่าสุดท้าย) จากนั้นในสายอื่น ( ¶) จะพิมพ์คำนำหน้าของบรรทัดปัจจุบันตามด้วยซึ่งแทรกคั่นและจากนั้นก็เริ่มค่าถัดไปที่,!1

ด่าน 3

!+
$.&

สิ่งนี้จะแปลง!จำนวนเต็มเป็นทศนิยมโดยแทนที่ด้วยความยาว

ด่านที่ 4

A`^,

และในที่สุดเราสังเกตเห็นว่าเราได้สร้างสองบรรทัดมากเท่าที่เราต้องการและครึ่งหนึ่งของพวกเขาเริ่มต้นด้วย,(ในตอนแรกที่เราตัดสินใจแยกออกแม้ว่าจะยังไม่มีอะไรจะแยกหลังจากนั้น) ,ดังนั้นเราทิ้งทุกสายที่เริ่มต้นด้วย

Perl, 44 ไบต์

รวม 3 สำหรับ-n(ใช้รหัส$'และ$0ดังนั้นจึงไม่สามารถนำมาใช้เป็น-ecommandline)

กำหนดหมายเลขให้กับพาร์ติชันบน STDIN:

partitions.pl <<< 4

partitions.pl

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

หากคุณไม่สนใจช่องว่างเพิ่มเติมในตอนท้ายของบรรทัดและมีการขึ้นบรรทัดใหม่พิเศษโซลูชัน 42 ไบต์นี้ทำงานด้วย (รันเป็นperl -M5.010 partitions.pl):

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

Julia, 113 Bytes

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

วิธีแก้ปัญหาแบบไม่เรียกซ้ำ

อธิบาย:

1. [vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N] สร้างชุดของรายการที่รวมกับ N ซึ่งการเรียงสับเปลี่ยนจะคล้ายกับโซลูชัน (เช่นสำหรับ N = 4: [[1,1,1,1], [1,1,2], [1,3], [4] ]])
2. map(x->[permutations(x)...],) คำนวณการเรียงสับเปลี่ยนทั้งหมด
3. reduce(vcat,) รวมไว้ในรายการของรายการ
4. unique() ตัวกรองซ้ำ

MATL , 15 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ให้ข้อมูลnนี้คำนวณพลังคาร์ทีเซียนกับ exponents ที่เพิ่มขึ้นkจาก1ถึงn; และสำหรับเลขชี้กำลังแต่ละตัวkเลือก tuples ที่มีผลรวมเท่ากับอินพุต

:       % 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 ไบต์

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)

เวอร์ชันที่ไม่ได้พัฒนา

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)

พบช่องว่างจรจัดและลบตัวแปรที่ไม่จำเป็นออกไปที่ปลอดภัย 11 ไบต์ ตามที่ปรากฎ table.insert () เป็นไบต์ที่ไม่มีประสิทธิภาพ

PHP, 125 ไบต์

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 ไบต์print_r($r);แทนecho json_encode($r);เอาต์พุต

โซลูชันแบบเรียกซ้ำที่มี 250 ไบต์

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 ไบต์ + 6 ไบต์เพื่อโทร

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.

ลองออนไลน์!
โทรด้วย[4]*L.ทำซ้ำ;จนกว่าจะมีการนำเสนอโซลูชั่นทั้งหมด

หรือหากกดซ้ำ ๆ;ไม่เป็นไร (หรือควรเพิ่มในจำนวนไบต์) การโทรbagof(L,[4]*L,M).ที่เพิ่ม 17 ไบต์สำหรับการโทร

J , 30 26 ไบต์

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

ทำงานโดยแยกรายการของ unary nโดยใช้ค่าไบนารีของ 2n

ลองออนไลน์!

คำอธิบาย

#&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

ที่จริงแล้ว17 16 ไบต์

คำตอบนี้จะขึ้นอยู่บางส่วนในคำตอบ MATL หลุยส์ Mendo ของ ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ ลองออนไลน์!

;╗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.

ที่จริงแล้ว17 16 15 ไบต์

นี่เป็นทางเลือกที่น่าสนใจของคำตอบ CJamของมาร์ตินเอนเดอร์ (อันที่มีผลิตภัณฑ์คาร์ทีเซียน) ซึ่งมีความแตกต่างในการใช้งานที่ฉันคิดว่าน่าสนใจ เมื่อหนึ่งในสตริงของ Martin เริ่มต้นด้วยการเพิ่มขึ้นข้อผิดพลาดจะป้องกันไม่ให้สตริงนั้นถูกประเมิน ในความเป็นจริงข้อผิดพลาดจะถูกระงับและสตริงที่มีการประเมินต่อไป เรื่องนี้จบลงด้วยการให้องค์ประกอบของทุกคนkในช่วง[1..n]ที่อยู่ในช่วง

แทนที่จะพยายามที่จะลบองค์ประกอบพิเศษฉันเอาn-1พลังคาร์ทีเซียนที่ th ของการ"1u"ผนวก a "1"ไปที่จุดเริ่มต้นของแต่ละสาย เคล็ดลับนี้ให้เพียงองค์ประกอบของ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.