Định nghĩa

Cho ma trận gồm các số nguyên không âm và số nguyên không âm , chúng tôi xác định là hàm "cắt nhỏ" để loại bỏ tất cả các hàng và tất cả các cột trong có chứa . $M$ $k$ $F_k$ $M$ $k$

Thí dụ:

\begin{aligned} M = (\begin{matrix} 6 & 1 & 5 \\ 1 & 2 & 8 \\ 9 & 8 & 5 \\ 6 & 0 & 4 \end{matrix}) \\ F_{5} (M) = (\begin{matrix} 1 & 2 \\ 6 & 0 \end{matrix}) \end{aligned}

$\begin{align}M=\pmatrix{\color{red}6&\color{red}1&\color{white}{\bbox[red,1pt]{5}}\\1&2&\color{red}8\\\color{red}9&\color{red}8&\color{white}{\bbox[red,1pt]{5}}\\6&0&\color{red}4}\\\\F_5(M)=\pmatrix{1&2\\6&0}\end{align}$

Nhiệm vụ của bạn

Với và một mục tiêu tổng , nhiệm vụ của bạn là phải tìm tất cả các giá trị có thể của sao cho tổng của các yếu tố còn lại trong là tương đương với . $M$ $S$ $k$ $F_k(M)$ $S$

Thí dụ:

Cho ma trận trên $M$ và $S=9$ :

$k=5$ là một giải pháp, bởi vì $F_5(M)=\pmatrix{1&2\\6&0}$ và $1+2+6+0=9$
$k=1$ là giải pháp khả thi duy nhất khác: $F_1(M)=\pmatrix{5\\4}$ và $5+4=9$

Vì vậy, sản lượng dự kiến sẽ là $\{1,5\}$ .

Làm rõ và quy tắc

Đầu vào được đảm bảo thừa nhận ít nhất một giải pháp.
Tổng số các yếu tố trong ma trận ban đầu là đảm bảo được lớn hơn $S$ .
Bạn có thể giả sử $S>0$ . Nó có nghĩa là một ma trận trống sẽ không bao giờ dẫn đến một giải pháp.
Các giá trị của $k$ có thể được in hoặc trả lại theo bất kỳ thứ tự nào và ở bất kỳ định dạng hợp lý, rõ ràng nào.
Bạn được phép không lặp lại đầu ra (ví dụ hoặc được coi là câu trả lời hợp lệ cho ví dụ trên). $[1,1,5,5]$ $[1,5,1,5]$
Đây là mã golf .

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

M = [[6,1,5],[1,2,8],[9,8,5],[6,0,4]]
S = 9
Solution = {1,5}

M = [[7,2],[1,4]]
S = 7
Solution = {4}

M = [[12,5,2,3],[17,11,18,8]]
S = 43
Solution = {5}

M = [[7,12],[10,5],[0,13]]
S = 17
Solution = {0,13}

M = [[1,1,0,1],[2,0,0,2],[2,0,1,0]]
S = 1
Solution = {2}

M = [[57,8,33,84],[84,78,19,14],[43,14,81,30]]
S = 236
Solution = {19,43,57}

M = [[2,5,8],[3,5,8],[10,8,5],[10,6,7],[10,6,4]]
S = 49
Solution = {2,3,4,7}

M = [[5,4,0],[3,0,4],[8,2,2]]
S = 8
Solution = {0,2,3,4,5,8}

code-golf array-manipulation matrix

— Arnauld
nguồn

Việc giữ lại cấu trúc ban đầu của mảng đầu vào (ví dụ, [[1,5],[1],[5],[]]đối với trường hợp thử nghiệm đầu tiên) có phải là một phương tiện đầu ra hợp lệ không?

— Xù xì

@Shaggy Vâng. Điều đó có vẻ hợp lý.

— Arnauld

10

K (ngn / k) , 39 byte

{a@&y=x{+//x*(&/'b)&\:&/b:~x=y}/:a:,/x}

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

cảm ơn @ Adám vì lời giải thích này :

{... }chức năng, xlà M và ylà S

,/x flatten M (đây là những ứng cử viên k )

a: giao cho a

x{... }/: áp dụng các chức năng sau đây để mỗi khi sử dụng M như là đối số trái cố định ( x):

x=y Ma trận Boolean cho biết các phần tử của M bằng ứng cử viên k hiện tại

~ phủ nhận rằng

b: giao nó cho b

&/ AND giảm (tìm các cột không có k )

(... )&\: VÀ rằng với mỗi người trong số những điều sau đây:

&/'b AND giảm của mỗi (tìm hàng mà không có k )

x* nhân M với điều đó

+// tổng hợp

y= danh sách Booleans chỉ ra nơi S bằng các khoản tiền đó

& chỉ số của Trues

a@ sử dụng để lập chỉ mục thành các yếu tố (các ứng cử viên k )

— ngn
nguồn

Hãy sửa lời giải thích.

— Adám

Sự nguy hiểm của lời giải thích sao chép dán

— Adám

6

APL (Dyalog Unicode) , 35 33 28 byte ^SBCS

-7 cảm ơn ngn.

Vô danh lambda. Đưa S làm đối số trái và M là đối số phải.

{⍵[⍸⍺=(+/∘,⍵×∧/∘.∧∧⌿)¨⍵≠⊂⍵]}

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

{... } "DFN", ⍺và ⍵đối số được trái và bên phải ( S và M ) lần lượt là:

⍵[... ] chỉ số M với các tọa độ sau đây:

⊂⍵ kèm theo M để coi nó như là một yếu tố duy nhất

⍵= so sánh từng yếu tố (tức là ứng cử viên k ) của M với toàn bộ M

(... )¨ áp dụng các chức năng ngầm sau đây để mỗi:

∧⌿ giảm AND dọc (tìm các cột không có ứng cử viên k đó )

... ∘.∧ sản phẩm Descartes Boolean với:

∧/ ngang VÀ giảm (tìm hàng không có ứng cử viên k )

⍵× nhân M với mặt nạ đó

+/∘, tổng ma trận dẹt

⍺= Boolean chỉ ra nơi S bằng các khoản tiền đó

⍸ chỉ số nơi đó là sự thật

— Adám
nguồn

1

{M[⍸⍺={+/,(∧⌿d)/M⌿⍨∧/d←M≠⍵}¨M←⍵]}

— ngn

@ngn Cảm ơn. Tuy nhiên, tôi sẽ không sử dụng toàn cầu vì nó khiến cho việc đánh giá trở nên khó hiểu: - Làm thế nào bạn có thể lập chỉ mục Mkhi nó chưa được tạo?

— Adám

vượt qua ⍵như ⍺trong dfn bên trong cũng khó hiểu đối với tôi

— ngn

{⍵[⍸⍺=+/¨(,⍵×∧/∘.∧∧⌿)¨⍵≠⊂⍵]}

— ngn

@ngn Vâng, tôi muốn làm một cái gì đó như thế. Cảm ơn!

— Adám

6

R , 78 73 byte

function(m,s)m[Map(function(y)sum(m[(w=-which(m==y,T))[,1],w[,2]]),m)==s]

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

Không sắp xếp hoặc lặp lại đầu ra.

Tín dụng cho J.Doe & Giuseppe cho -5 byte.

— Kirill L
nguồn

4

76 byte

— J.Doe

4

@ J.Doe 73 byte

— Giuseppe

5

Thạch , 20 19 17 15 14 byte

pZnⱮFȦ€€ḋFẹƓịF

Đây là một liên kết đơn âm lấy M làm đối số và đọc S từ STDIN.

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

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

pZnⱮFȦ€€ḋFẹƓịF  Main link. Argument: M

 Z              Zip; transpose the rows and columns of M.
p               Take the Cartesian product of M and its transpose, yielding all pairs
                (r, c) of rows and columns of M.
    F           Flatten; yield the elements of M.
  nⱮ            Not equal map; for each element e of M, compare the elements of the
                pairs (r, c) with e.
     Ȧ€€        All each each; for each array of Booleans corresponding to an (r, c)
                pair, test if all of them are true.
         F      Flatten; yield the elements of M.
        ḋ       Take the dot product of each list of resulting Booleans and the
                elements of M.
           Ɠ    Read an integer S from STDIN.
          ẹ     Find all indices of S in the dot products.
             F  Flatten; yield the elements of M.
            ị   Retrieve the elements of the right at the indices from the left.

— Dennis
nguồn

Đánh dấu lời của tôi lol :) Câu trả lời hay, +1

— Ông Xcoder

5

Haskell , 88 86 84 77 byte

-2 byte nhờ vào BWO
-7 byte nhờ Tesseract

m!s=[k|k<-m>>=id,s==sum[x|r<-m,all(/=k)r,(i,x)<-zip[0..]r,all((/=k).(!!i))m]]

Xác nhận tất cả các testcase .

Giải trình

m ! s =                                         -- function !, taking m and s as input
    [k |                                        -- the list of all k's such that
        k <- m >>= id,                          -- * k is an entry of m
        s == sum                                -- * s equals the sum of
            [x |                                --     the list of x's such that
                r <- m,                         --     * r is a row of m
                all (/= k) r,                   --     * r does not contain k
                (i, x) <- zip [0 ..] r,         --     * i is a valid column index; also let x = r[i]
                all ((/= k) . (!! i)) m         --     * none of the rows contain k at index i
            ]
    ]

— Delfad0r
nguồn

Điều đó có nên nói chức năng của Nhật Bản không?

— Quintec

1

@Quintec Quả thực là cần, nhưng tôi đã đổi nó thành "hàm!" để tiết kiệm 2 byte nhờ vào BWO

— Delfad0r

5

Pyth , 27 23 22 21 20 byte

fqvzss.DRsxLTQ-I#TQs

Bộ thử nghiệm!

Không trùng lặp.

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

fqvzss.DRsxLTQ-I#TQs     Full program.
f                  s     Flatten M and keep only those elements T which satisfy:
 qvzss.DRsxLTQ-I#TQ      The filtering function. Breakdown:
              -I#TQ      Discard the rows that contain T. More elaborate explanation:
                # Q         |-> In M, keep only those elements that are...
               I            |-> Invariant under (equal to themselves after...)
              -  T          |-> Removing T.
                         Let's call the result of this expression CR (chopped rows).
          xLTQ           Map over the rows M and retrieve all indices of T.
         s               Collect indices in 1D list (flatten). Call this I.
      .DR                For each row left in CR, remove the elements at indices in I.
    ss                   Sum all the elements of this matrix flattened.
 qvz                     And then finally check whether they equal S.

— Ông Xcoder
nguồn

4

Python 2 , 114 108 byte

lambda m,s:{a for a in sum(m,[])if s==sum(v for l in m for i,v in enumerate(l)if{a}-set(l)-set(zip(*m)[i]))}

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

— TFeld
nguồn

4

Perl 6 , 80 74 byte

->\m,\s{grep {s==sum m[m.$_;[[Z](m).$_]]}o{*.grep(:k,!*.grep($_))},m[*;*]}

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

Giải trình

->\m,\s{...}  # Anonymous block taking arguments m and s
  grep {...}o{...},m[*;*]   # Filter matrix elements
                            # with combination of two functions
    *.grep(:k,!*.grep($_))  # (1) Whatever code returning matching rows
    s==sum m[               # (2) s equals sum of elements
      m.$_;                 #     in matched rows
      [                     #     (array supporting multiple iterations)
       [Z](m).$_            #     and matched columns (matched rows
                            #     of m transposed with [Z])
      ]
    ]

— nwellnhof
nguồn

3

05AB1E , 21 byte

²˜ʒQεZ+}øεZ<~}ø_*OO¹Q

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

Chỉ sau khi tôi viết câu trả lời này, tôi mới thấy Kevin's . Tôi tin rằng điều này là khác nhau đáng kể, vì vậy tôi đang đăng nó một cách riêng biệt. Trực giác của tôi nói rằng số byte tối ưu là khoảng 18, vì vậy tôi sẽ phải xem lại điều này và xem những gì tôi có thể làm. Với mã hiện tại, không thể viết một bộ thử nghiệm nhưng tôi đã tự mình xác minh tất cả các trường hợp thử nghiệm và kết quả là chính xác.

Thuật toán cắt

Để minh họa rõ hơn về kỹ thuật được sử dụng, hãy lấy một ví dụ, với phần tử là crop : $k=5$

M = (\begin{matrix} 6 & 1 & 5 \\ 1 & 2 & 8 \\ 9 & 8 & 5 \\ 6 & 0 & 4 \end{matrix})

$M=\left(\begin{matrix}6&1&\bbox[green,1pt]{\color{white}{5}}\\1&2&8\\9&8&\bbox[green,1pt]{\color{white}{5}}\\6&0&4\end{matrix}\right)$

Đầu tiên, nó tạo ra ma trận đẳng thức với : $k$

(\begin{matrix} 0 & 0 & 1 \\ 0 & 0 & 0 \\ 0 & 0 & 1 \\ 0 & 0 & 0 \end{matrix})

$\left(\begin{matrix}0&0&1\\0&0&0\\0&0&1\\0&0&0\end{matrix}\right)$

Sau đó, nó đi qua và cho mỗi hàng , nó thêm cho mỗi phần tử trong , làm nổi bật các hàng cần thiết trong khi vẫn giữ được tính duy nhất của các vị trí nằm ngang của phần tử được tìm kiếm: $M$ $R$ $\max(R)$ $R$

(\begin{matrix} 1 & 1 & 2 \\ 0 & 0 & 0 \\ 1 & 1 & 2 \\ 0 & 0 & 0 \end{matrix})

$\left(\begin{matrix}\color{green}{1}&\color{green}{1}&\bbox[green,1pt]{\color{white}{2}}\\0&0&0\\\color{green}{1}&\color{green}{1}&\bbox[green,1pt]{\color{white}{2}}\\0&0&0\end{matrix}\right)$

Sau đó, nó đi qua chuyển vị của và với mỗi cột , nó thực hiện thao tác (trong đó là 05AB1E của bitwise HOẶC - bổ sung cũng hoạt động, vì vậy thay thế bằng nếu bạn cũng muốn kiểm tra điều đó), kết quả là: $M$ $C$ $(\max(C)-1)\space ||\space c\space\forall\space c\in C\:$ $||$ ~+

(\begin{matrix} 1 & 1 & 3 \\ 0 & 0 & 1 \\ 1 & 1 & 3 \\ 0 & 0 & 1 \end{matrix})

$\left(\begin{matrix}\color{green}{1}&\color{green}{1}&\bbox[green,1pt]{\color{white}{3}}\\0&0&\color{green}{1}\\\color{green}{1}&\color{green}{1}&\bbox[green,1pt]{\color{white}{3}}\\0&0&\color{green}{1}\end{matrix}\right)$

Cuối cùng, nó ánh xạ đến và tất cả các số nguyên khác thành và thực hiện phép nhân phần tử với : $0$ $1$ $0$ $M$

(\begin{matrix} 0 & 0 & 0 \\ 1 & 1 & 0 \\ 0 & 0 & 0 \\ 1 & 1 & 0 \end{matrix}) ⟶ (\begin{matrix} 0 & 0 & 0 \\ 1 & 2 & 0 \\ 0 & 0 & 0 \\ 6 & 0 & 0 \end{matrix})

$\left(\begin{matrix}\color{green}{0}&\color{green}{0}&\color{green}{0}\\1&1&\color{green}{0}\\\color{green}{0}&\color{green}{0}&\color{green}{0}\\1&1&\color{green}{0}\end{matrix}\right)\:\longrightarrow\:\left(\begin{matrix}\color{green}{0}&\color{green}{0}&\color{green}{0}\\1&2&\color{green}{0}\\\color{green}{0}&\color{green}{0}&\color{green}{0}\\6&0&\color{green}{0}\end{matrix}\right)$

Sau đó, tổng của ma trận kết quả được tính toán.

— Ông Xcoder
nguồn

1

Câu trả lời tốt đẹp! Tôi biết chắc chắn tôi sẽ chơi được golf. Tôi đã đủ hạnh phúc để nó hoạt động, bao gồm cả trường hợp gây phiền nhiễu cho [[1,1,0,1],[2,0,0,2],[2,0,1,0]]tôi về số lượng 1(loại bỏ mọi cột ..) Tôi thực sự có một chút dưới 20 trong đầu cũng như khả năng. Quá tệ, hầu như không có bất kỳ nội dung nào cho ma trận, mặc dù các sản phẩm được thêm vào gần đây. Đối với 1|2( 1 2~trong 05AB1E synthax) dẫn đến 3, điều này là do các logical ORhành động giống như một binary ORsố khi không có 0/ 1có liên quan (tôi nghĩ / giả định).

— Kevin Cruijssen

@KevinCruijssen ơi bạn nói đúng! Sau đó, các tài liệu nên viết bit OR , không logic OR . Tôi sẽ phải sửa nó sớm. Dù sao, bitwise HOẶC cũng nên làm việc như tôi nghĩ. Nó có thể được thay thế bằng +dù sao tôi đoán, vì vậy tôi hy vọng sẽ không có vấn đề gì với nó :)

— Ông Xcoder

2

05AB1E (di sản) , 27 26 byte

˜ʒ©¹ε®å_}¹ζʒ®å_}ζ‚ζ€€OPOIQ

Không sắp xếp cũng không xác định kết quả.
Chỉ hoạt động theo di sản (hiện tại), bởi vì mỗi phần dường như đang thực hiện một số điều kỳ lạ khi một phần của danh sách bên trong là số nguyên và phần khác là danh sách ..

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

˜              # Flatten the (implicit) matrix-input
               #  i.e. [[6,1,5],[1,2,8],[9,8,5],[6,0,4]] → [6,1,5,1,2,8,9,8,5,6,0,4]
 ʒ             # Filter this list by:
  ©            #  Store the current value in a register-variable
   ¹           #  Take the matrix-input
    ε   }      #  Map it to:
     ®å_       #   0 if the current number is in this row, 1 if not
               #    i.e. [[6,1,5],[1,2,8],[9,8,5],[6,0,4]] and 6 → [0,1,1,0]
   ¹           #  Take the matrix-input again
    ζ          #  Swap its rows and columns
               #   i.e. [[6,1,5],[1,2,8],[9,8,5],[6,0,4]] → [[6,1,9,6],[1,2,8,0],[5,8,5,4]]
     ʒ   }     #  Filter it by:
      ®å_      #   Only keep the inner lists that does not contain the current number
               #    i.e. [[6,1,9,6],[1,2,8,0],[5,8,5,4]] and 6 → [[1,2,8,0],[5,8,5,4]]
               #    i.e. [[1,2,2],[1,0,0],[0,0,1],[1,2,0]] and 1 → []
          ζ    #  After filtering, swap it's rows and columns back again
               #   i.e. [[1,2,8,0],[5,8,5,4]] → [[1,5],[2,8],[8,5],[0,4]]
   ‚ζ          #  Pair both lists together and zip them
               #   i.e. [0,1,1,0] and [[1,5],[2,8],[8,5],[0,4]]
               #    → [[0,[1,5]],[1,[2,8]],[1,[8,5]],[0,[0,4]]]
               #   i.e. [0,1,0] and [] → [[0,' '],[1,' '],[0,' ']]
     €         #  Map each inner list / value to:
      €O       #   Sum each
               #    i.e. [[0,[1,5]],[1,[2,8]],[1,[8,5]],[0,[0,4]]]
               #     → [[0,6],[1,10],[1,13],[0,4]]
               #    i.e. [[0,' '],[1,' '],[0,' ']]
               #     → [[0,0],[1,0],[0,0]]
               #  (NOTE: For most test cases just `O` instead of `€€O` would be enough,
               #   but not if we removed ALL zipped inner lists for a number, like the 
               #   second example above with input [[1,1,0,1],[2,0,0,2],[2,0,1,0]] and 1)
        P      #  Now take the product of each inner list
               #   i.e. [[0,6],[1,10],[1,13],[0,4]] → [0,10,13,0]
         O     #  Then take the sum of those
               #   i.e. [0,10,13,0] → 23
          IQ   #  And only keep those that are equal to the number-input
               #   i.e. 23 and 9 → 0 (falsey), so it's removed from the flattened input

— Kevin Cruijssen
nguồn

1

Thạch , 22 byte

=+Ṁ$€Z$⁺’¬×⁸FS
F³ç=⁹ƲƇ

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

-6 byte sử dụng cách tiếp cận chung từ câu trả lời 05AB1E của ông Xcoder.

— HyperNeutrino
nguồn

1

Than , 33 byte

ＦθＦι⊞υκＩΦυ⁼ηΣＥθ∧¬№λιΣＥλ∧¬№Ｅθ§πξιν

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã và bao gồm sự trùng lặp. Giải trình:

ＦθＦι⊞υκ

Làm phẳng mảng đầu vào đầu tiên vào qdanh sách được xác định trước u.

  υ                          Flattened array
 Φ                           Filter elements
       θ                     Input array
      Ｅ                      Map over rows
            ι                Current element
           λ                 Current row
          №                  Count matching elements
         ¬                   Logical Not
        ∧                    Logical And
               λ             Current row
              Ｅ              Map over columns
                    θ        Input array
                   Ｅ         Map over rows
                      π      Inner row
                       ξ     Column index
                     §       Inner element
                        ι    Current element
                  №          Count matching elements
                 ¬           Logical Not
                ∧            Logical And
                         ν   Current element
             Σ               Sum
     Σ                       Sum
    η                        Second input
   ⁼                         Equals
Ｉ                            Cast to string
                             Implicitly print each result on its own line

Đối với mỗi phần tử của danh sách, tính tổng mảng, nhưng nếu hàng chứa phần tử thì sử dụng 0thay cho tổng của nó và khi tính tổng các hàng không chứa phần tử, nếu cột chứa phần tử thì sử dụng 0thay vì giá trị của cột . Điều này rất khó chơi hơn so với việc lọc các yếu tố vì Char than không thể tổng hợp một danh sách trống.

— Neil
nguồn

1

Sạch , 92 byte

import StdEnv
$m s=[c\\r<-m,c<-r|sum[b\\a<-m|all((<>)c)a,b<-a&x<-[0..]|all(\u=u!!x<>c)m]==s]

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

Giải thích:

$ m s                       // the function $ of `m` and `s`
 = [                        // is equal to
  c                         // the value `c`
  \\ r <- m                 // for every row `r` in `m`
  , c <- r                  // for every value `c` in `r`
  | sum [                   // where the sum of
   b                        // the value `b`
   \\ a <- m                // for every row `a` in `m`
   | all ((<>)c) a          // where `c` isn't in `a`
   , b <- a                 // for every value `b` in `a`
   & x <- [0..]             // with every column index `x` from zero
   | all (\u = u!!x <> c) m // where `c` isn't in column `x`
  ] == s                    // equals `s`
 ]

— Urous
nguồn

1

MATLAB - 80 byte

(Đã sửa và ) Nén:

function f(M,s);for k=M(:)';if sum(sum(M(~sum(M==k,2),~sum(M==k))))==s;k,end;end

Và trong một phiên bản phát triển đầy đủ:

function getthesum(M,s)

for k=M(:)'                         % For each element of M
    x = M==k ;                      % Index elements equal to "k"
    N = M( ~sum(x,2) , ~sum(x) ) ;  % New matrix with only the appropriate rows/columns
    if sum(sum(N))==s               % sum rows and columns and compare to "s"
        k                           % display "k" in console if "k" is valid
    end
end

Nhờ các ý kiến để làm nổi bật sai lầm ban đầu của tôi. Lưu ý rằng phiên bản này không nhân đôi đầu ra.

Có thể sao chép đầu ra với 5 byte nữa:

% This will only cycle through the unique elements of 'M' (85 bytes):

function f(M,s);for k=unique(M)';if sum(sum(M(~sum(M==k,2),~sum(M==k))))==s;k,end;end

— Hoki
nguồn

1

k có thể là bất kỳ phần tử nào của ma trận.

— Dennis

@Dennis, ôi đúng rồi ... Thật tệ, tôi sẽ sửa nó sau hôm nay. Cảm ơn đã chỉ ra điều đó.

— Hoki

1

@Arnauld. Xin lỗi tôi đã được nghỉ, mà nó đã sửa bây giờ.

— Hoki

Cắt bỏ ma trận để có được số tiền mong muốn

Định nghĩa

Nhiệm vụ của bạn

Làm rõ và quy tắc

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

K (ngn / k) , 39 byte

APL (Dyalog Unicode) , 35 33 28 byte SBCS

R , 78 73 byte

Thạch , 20 19 17 15 14 byte

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

Haskell , 88 86 84 77 byte

Giải trình

Pyth , 27 23 22 21 20 byte

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

Python 2 , 114 108 byte

Perl 6 , 80 74 byte

Giải trình

05AB1E , 21 byte

Thuật toán cắt

05AB1E (di sản) , 27 26 byte

Thạch , 22 byte

Than , 33 byte

Sạch , 92 byte

MATLAB - 80 byte

APL (Dyalog Unicode) , 35 33 28 byte ^SBCS