Thách thức này, trong khi có lẽ tầm thường trong hầu hết các ngôn ngữ "tiêu chuẩn", được đề cập đến những ngôn ngữ rất bí truyền, trình độ thấp và / hoặc khó sử dụng mà rất hiếm thấy trên trang web này. Nó sẽ cung cấp một vấn đề thú vị để giải quyết, vì vậy đây là dịp để bạn thử ngôn ngữ kỳ lạ mà bạn đã đọc!

Nhiệm vụ

Lấy hai số tự nhiên avà blàm đầu vào, và xuất hai số khác: kết quả của phép chia số nguyên a/bvà phần còn lại của phép chia đó ( a%b).

Đây là code-golf : câu trả lời ngắn nhất (tính bằng byte), cho mỗi ngôn ngữ, sẽ thắng!

Đầu ra đầu vào

• 0 <= a<= 255, 1 <= b<= 255. Mỗi đầu vào của bạn (và cả đầu ra cũng vậy) sẽ vừa trong một byte.
• Bạn có thể chọn bất kỳ định dạng nào bạn thích cho cả đầu vào và đầu ra, miễn là hai số có thể phân biệt rõ ràng (ví dụ: không in hai kết quả với nhau mà không có dấu phân cách)

Ví dụ

a,b->division,remainder
5,7->0,5
5,1->5,0
18,4->4,2
255,25->10,5

Lưu ý: Các nội dung trả về cả kết quả của phép chia và phần còn lại đều bị cấm . Ít nhất cho chúng tôi thấy cách ngôn ngữ của bạn xử lý việc áp dụng hai hàm cho cùng một đối số.

Lưu ý 2: Như mọi khi, một lời giải thích về cách mã của bạn hoạt động rất được hoan nghênh, ngay cả khi nó có vẻ dễ đọc đối với bạn, nó có thể không như vậy đối với người khác!

Bảng xếp hạng

Dưới đây là một Đoạn trích để tạo tổng quan về người chiến thắng theo ngôn ngữ.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Nếu bạn muốn bao gồm nhiều số trong tiêu đề của mình (ví dụ: vì điểm của bạn là tổng của hai tệp hoặc bạn muốn liệt kê riêng các hình phạt cờ của thông dịch viên), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

# Perl, 43 + 2 (-p flag) = 45 bytes

Bạn cũng có thể đặt tên ngôn ngữ thành một liên kết mà sau đó sẽ hiển thị trong đoạn trích bảng xếp hạng:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=114003,OVERRIDE_USER=62393;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={};e.forEach(function(e){var o=e.language;/<a/.test(o)&&(o=jQuery(o).text().toLowerCase()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link,uniq:o}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.uniq>s.uniq?1:e.uniq<s.uniq?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=617d0685f6f3"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>

BitCycle , 146 79 64 byte

Chỉ cần nhận ra toàn bộ phần mã gốc của tôi là không cần thiết. Giảm rất nhiều!

v  <>!
A\B^^=
? D^>^<
 >\v^~ D@
 >/ C/
  > C ^
A/B v
^   <
?  D^

Chương trình lấy đầu vào unary từ dòng lệnh, với ước số đầu tiên. Nó xuất ra thương số và phần còn lại trong unary, cách nhau bởi a 0. Ví dụ, đây là a=11, b=4, a/b=2, a%b=3:

C:\>python bitcycle.py divmod.btc 1111 11111111111
110111

Ungolfed, trong hành động

Đây là phiên bản điện toán không được chỉnh sửa của tôi a=3, b=5với hoạt hình được bật (xin lỗi về sự rối mắt):

Cố gắng giải thích

Giải thích áp dụng cho phiên bản không có người nhận. Trước khi bạn giải quyết nó, tôi khuyên bạn nên đọc trang Esolang để cảm nhận về cách ngôn ngữ hoạt động.

Thuật toán diễn ra như sau:

• Chạy một vòng lặp bên ngoài cho đến khi chương trình kết thúc.
  • Chạy một vòng lặp bên trong qua các bit của ước số, ghép chúng với các bit từ cổ tức.
    • Nếu tất cả các bit của ước số có các bit cổ tức phù hợp, hãy xuất một bit đơn.
    • Nếu không phải tất cả các bit của ước số đều có các bit cổ tức phù hợp, hãy xuất ra dấu phân cách 0theo sau các bit cổ tức đã có, sau đó chấm dứt.

Trung tâm của mã là các mối quan hệ giữa các nhà sưu tập (các chữ cái viết hoa). Vì có nhiều nhà sưu tập riêng biệt với mỗi chữ cái, chúng ta hãy gọi chúng là A1, A2, B1, B2vv, đánh số từ trên xuống dưới.

• A1và A2giữ số chia và cổ tức, tương ứng, ở đầu vòng lặp chính.
• Vòng lặp bên trong tách ra từng chút một từ số chia và cổ tức.
  • Phần còn lại của ước, nếu có, luôn luôn đi vào B1.
  • Nếu cả số chia và cổ tức đều không có giá trị, một bit đi vào C1và một vào C3. Phần còn lại của cổ tức đi vào B2.
  • Nếu chỉ có số chia là không có giá trị, chúng tôi đã đạt đến cuối cổ tức và đã đến lúc in phần còn lại. Các bit từ ước số đi vào C2.
  • Nếu chỉ có cổ tức là không có giá trị, chúng tôi đã đạt đến kết thúc của ước số; đã đến lúc xử lý các bit trong C3hoặc C2cho đầu ra. Phần còn lại của cổ tức đi vào C4.
• Nếu có bất kỳ bit nào trong Bbộ sưu tập, chúng sẽ quay vòng nội dung của chúng trở lại Abộ sưu tập và tiếp tục trong vòng lặp bên trong.
• Khi Avà Bnhà sưu tập đều có sản phẩm nào, các Cnhà sưu tập mở và chúng tôi tiến tới giai đoạn xử lý:
  • C1và C4đổ nội dung của chúng (số chia và cổ tức còn lại, tương ứng) vào D1và D3.
  • Nếu C2trống, chúng tôi vẫn in thương số.
    • Các nội dung C3đi lên trên =chuyển đổi bên phải trên cùng . 1Bit đầu tiên truyền thẳng đến !và là đầu ra.
    • Khi 1bit đi qua, nó kích hoạt công tắc để trỏ sang phải, nó sẽ gửi tất cả các bit tiếp theo ra khỏi bảng.
  • Nếu C2không trống, chúng tôi sẽ in phần còn lại.
    • Bit đầu tiên C2được phủ định thành a 0và được chuyển qua công tắc. Tiếp 0tục !và là đầu ra.
    • Khi 0bit đi qua, nó kích hoạt công tắc để hướng sang trái. Bây giờ tất cả các bit từ C3trái sang phải từ công tắc và được chuyển hướng xung quanh vào !, xuất ra toàn bộ phần còn lại.
    • Một bản sao của bit đầu tiên C2cũng được gửi vào D2.
• Bây giờ các Dnhà sưu tập mở.
  • Nếu có bất cứ điều gì D2, có nghĩa là chúng tôi chỉ in phần còn lại. Các bit từ D2hit @, mà chấm dứt chương trình.
  • Mặt khác, nội dung của D1và D3lặp lại vào A1và A2tương ứng, và vòng lặp chính bắt đầu lại.

Brainfuck , 43 41 byte

,<,[>->+<[>]>>>>+<<<[<+>-]<<[<]>-]>>.>>>.

Điều này sử dụng một phiên bản sửa đổi của thuật toán mô đun phá hủy của tôi trên Esolang .

Chương trình đọc hai byte - d và n , theo thứ tự đó - từ STDIN và in hai byte - n% d và n / d , theo thứ tự đó - sang STDOUT. Nó đòi hỏi một trình thông dịch Brainfuck với một cuộn băng vô hạn hoặc tròn gấp đôi, chẳng hạn như băng thông trên TIO.

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

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

Trước khi chương trình bắt đầu, tất cả các ô giữ giá trị 0 . Sau khi đọc d từ STDIN ( ,), di chuyển một bước sang trái ( <) và đọc n từ STDIN ( ,), băng trông như sau.

       v
A      B      C      D      E      F      G      H      J
0      n      d      0      0      0      0      0      0

Tiếp theo, giả sử rằng n> 0 , chúng ta nhập vòng lặp while

[>->+<[>]>>>>+<<<[<+>-]<<[<]>-]

mà biến đổi các băng như sau.

Thứ nhất, >->+<tiến đến ô C và decrements nó, sau đó tiến đến ô D và gia số nó, và cuối cùng quay ngược lại tế bào C . Điều gì xảy ra tiếp theo phụ thuộc vào giá trị của ô C bằng 0 hay không.

• Nếu tế bào C giữ một giá trị tích cực, [>](đi bên phải trong khi các tế bào không phải là zero) sẽ tiến tới tế bào E .

  >>>>+<<<tiến đến ô J để tăng nó, sau đó quay ngược lại đến ô F .

  Kể từ tế bào F sẽ luôn giữ 0 , trong khi vòng lặp [<+>-]được bỏ qua hoàn toàn, và <<đi trở lại tế bào D .

  Cuối cùng, vì không D hay C giữ 0 , [<](sang trái trong khi các tế bào không phải là zero) sẽ retrocede để tế bào Một .

• Nếu ô C giữ 0 , vòng lặp [>]bị bỏ qua hoàn toàn; >>>>+<<<tiến tới tế bào G để tăng nó, sau đó quay ngược lại tế bào D .

  Tại thời điểm này, D sẽ giữ d (trên thực tế, tổng các giá trị trong C và D sẽ luôn là d ), vì vậy [<+>-](trong khi D là dương, tăng C và giảm D ) sẽ đặt C thành d và D thành 0 .

  Cuối cùng, <<retrocedes để tế bào B , [<](sang trái trong khi các tế bào không phải là zero) tiếp tục còn lại để tế bào Một .

Trong cả hai trường hợp, >-tiến tới ô B và làm giảm nó và vòng lặp bắt đầu lại trừ khi điều này làm nó biến mất.

Sau khi lặp lại k , băng trông như sau.

       v
A      B      C      D      E      F      G      H      J
0      n-k    d-k%d  k%d    0      0      k/d    0      k-k/d

Sau n lần lặp B là 0 và chúng ta thoát ra khỏi vòng lặp. Các giá trị mong muốn ( n% d và n / d ) sẽ được lưu trữ trong các ô D và G , vì vậy hãy >>.>>>.in chúng.

Funciton , 224 108 byte

Số lượng byte giả định mã hóa UTF-16 bằng BOM.

 ┌──┬───┐
┌┴╖╓┴╖ ┌┴╖
│%╟║f╟┐│÷╟┘
╘╤╝╙─╜│╘╤╝
 └────┴─┘

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

Ở trên định nghĩa một hàm f, có hai số nguyên và trả về cả phép chia và sản phẩm của chúng (các hàm trong Funciton có thể có nhiều đầu ra miễn là tổng số đầu vào và đầu ra không vượt quá 4).

Sử dụng hai giá trị đầu vào cho nhiều mục đích thực sự khá tầm thường: bạn chỉ cần tách đầu nối với một điểm nối T ở giá trị sẽ được sao chép dọc theo cả hai nhánh, sau đó chúng ta có thể cung cấp riêng cho các phần tử tích hợp để chia và modulo.

Tôi thực sự phải mất gấp đôi thời gian để tìm ra cách hiển thị kết quả cho người dùng thay vì chỉ thực hiện giải pháp.

Ngoài ra, Funciton có một divmod tích hợp, ÷%và thật thú vị là các phần dựng sẵn ÷và %giải pháp sử dụng của tôi được triển khai theo các khía cạnh ÷% . Tuy nhiên, chức năng của tôi fở trên không hoàn toàn giống với ÷%: Tôi đã phải trao đổi thứ tự của các đầu vào và mặc dù có vẻ như nó dễ dàng thay đổi điều đó, cho đến nay tôi vẫn không thể làm như vậy mà không tăng số byte .

JavaScript (ES6), 17 byte

Cảm ơn @Arnauld vì đã chơi golf một byte

x=>y=>[x/y|0,x%y]

Nhận đầu vào ở định dạng (x) (y)

Nhận sàn của x / y bằng cách thực hiện theo bitwise hoặc
Nhận phần còn lại bằng x% y
Đặt cả hai giá trị trong một mảng để cả hai có thể được trả về

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

APL (Dyalog) , 5 byte

-2 byte nhờ @ngn

⌊÷,|⍨

Đây là một đỉnh (2 tàu) của một ngã ba (3 tàu), trong đó cột bên phải của đỉnh là một hàm xuất phát (kết quả của một toán tử được áp dụng cho một hàm):

       result 
         ↑┌──────────┐
         ││    ┌────┐│┌──────┐ (derived function)
         │↓    │    ↓│↓      │╱
       ┌───┐ ┌───┐ ┌───┐ ╔═══╤═══╗
       │ ⌊ │ │ ÷ │ │ , │ ║ | │ ⍨ ║ 
       └───┘ └───┘ └───┘ ╚═══╧═══╝
              ↑ ↑         ↑     ↑ ╲
left argument ┴─────────────────┘  (operator)
                └─────────┴ right argument

⌊ sàn của

÷ bộ phận

, catenated

| phần còn lại
⍨ với các đối số hoán đổi (mô đun APL là "ngược")

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

Brachylog , 6 byte

{÷|%}ᶠ

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

Giải trình

Chúng tôi lạm dụng siêu dữ liệu ᶠ findallđể áp dụng hai vị từ khác nhau vào danh sách Nhập của hai đối số:

{   }ᶠ         Findall for the Input [A,B] :
 ÷               Integer division
  |              Or…
   %             Modulo

MATL , 12 10 byte

Qt:ie=&fhq

Đầu vào là avậy b. Đầu ra là phần còn lại, sau đó là thương.

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

Giải trình

Điều này tránh cả modulo và phân chia. Thay vào đó, nó sử dụng định hình lại mảng :

1. Xây dựng một loạt các a+1yếu tố khác không.
2. Định hình lại như một mảng 2D của bcác hàng. Điều này tự động đệm với số không nếu cần thiết.
3. Các chỉ số hàng và cột của mục nhập khác không, trừ đi 1, tương ứng là phần còn lại và thương.

Xem xét ví dụ a=7, b=3.

Q    % Input a implicitly. Push a+1
     % STACK: 8
t:   % Duplicate. Range from 1 to that
     % STACK: 8, [1 2 3 4 5 6 7 8]
ie   % Input b. Reshape as a matrix with b rows (in column major order)
     % STACK: 8, [1 4 7;
                  2 5 8]
                  3 6 0]
=    % Compare for equality
     % STACK: [0 0 0;
               0 0 1;
               0 0 0]
&f   % Row and column indices (1-based) of nonzero element
     % STACK: 2, 3
hq   % Concatenate. Subtract 1. Implicitly display
     % STACK: [1 2]

Toán học, 20 18 byte

⌊#/#2⌋@Mod@##&

Lạm dụng nhỏ các quy tắc đầu ra linh hoạt: kết quả được đưa ra là div[mod], sẽ vẫn không được đánh giá. Các số riêng lẻ có thể được trích xuất với result[[0]]và result[[1]].

Và này, nó chỉ dài hơn một byte so với tích hợp có tên lố bịch QuotientRemainder.

Mathicala, thực sự có một cách gọn gàng để áp dụng nhiều hàm cho cùng một đầu vào, nhưng nó dài hơn ba byte:

Through@*{Quotient,Mod}

05AB1E , 5 byte

÷²¹%‚

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

05AB1E có một lỗi, vì vậy đầu vào ngầm không hoạt động :( Emigna lưu ý rằng đầu vào thường bị đẩy ngược lại.

Sứa , 14 byte

p
m
,|S
% i
Ei

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

Giải trình

Sứa là một ngôn ngữ đẹp khi áp dụng nhiều chức năng cho cùng một đầu vào. Ngôn ngữ là 2D và tất cả các hàm nhị phân nhìn về phía nam cho một đầu vào và phía đông cho một đầu vào khác. Vì vậy, bằng cách tiếp cận một giá trị từ phía tây và từ phía bắc, chúng ta có thể cung cấp cho hai hàm mà không cần phải sao chép nó trong mã.

Hai is trong chương trình được thay thế bằng hai giá trị đầu vào khi chương trình bắt đầu. Bây giờ %là phân chia. Nó nhận một đầu vào trực tiếp từ phía đông, và khi đi về phía nam, nó chạm vào Ehướng chuyển hướng tìm kiếm ở phía đông. Vì vậy, cả hai đầu vào được đưa vào %làm đối số.

| là tích hợp sẵn cho modulo, về cơ bản cũng làm điều tương tự, nhưng cuối cùng lại nhìn về phía nam cho cả hai vị trí.

Chúng tôi ghép cả hai kết quả thành một cặp với ,. Sau đó mlà hàm sàn (mà chúng ta cần vì %là phép chia dấu phẩy động) và cuối cùng chúng ta in kết quả với p.

Hình khối , 12 13 byte

;W@o,I|\S%;O

Bản đồ nào vào khối sau

    ; W
    @ o
, I | \ S % ; O
. . . . . . . .
    . .
    . .

Hãy thử nó ở đây

Giải thích với các bước như được thực hiện
,I|I,- bắt đầu bằng phép chia số nguyên siêu, lấy số nguyên đầu tiên từ đầu vào, phản xạ lại và lấy số nguyên tiếp theo từ đầu vào, sau đó chia lại
O;- Xuất kết quả của phép chia số nguyên và bật nó
%- thực hiện mod. Điều này có thể được thực hiện sau đó, nhưng kết thúc tại đây
S\o- Thêm ký tự không gian để xếp chồng, chuyển hướng lên và xuất không gian
W;- Chuyển sang trái và bật không gian từ ngăn xếp
O|@- Xuất ra mod đã tính trước đó, chuyển qua bộ phản xạ ngang và tạm dừng.

Brain-Flak , 56 54 byte

({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

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

-2 byte nhờ Wheat Wizard

Giải trình

Phép chia số nguyên và modulo được biết đến nhiều nhất hiện nay trong Brain-Flak rất giống nhau (trên thực tế, phép chia số nguyên hiện đang được sử dụng chỉ là một sửa đổi tôi đã thực hiện trên frageum modulo của ).

Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

Thuận tiện, chương trình phân chia số nguyên chỉ sử dụng ngăn xếp thứ ba để lưu trữ dữ liệu trong khi chương trình modulo chỉ sử dụng hai ngăn xếp thông thường để lưu trữ dữ liệu. Do đó, chỉ cần chạy cả hai cùng một lúc chúng không va chạm vào nhau.

Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

Combined: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><([{}()]{})>)

Cuối cùng, cả hai chương trình phân chia số nguyên và modulo được sử dụng trong tổ hợp này được thiết kế để ngăn xếp sạch sẽ (không để lại rác trên ngăn xếp / không phụ thuộc vào sự tồn tại (không) của các giá trị trên ngăn xếp ngoài đầu vào của chúng) nhưng điều đó là không cần thiết cho vấn đề này Do đó, chúng ta có thể lưu hai byte bằng cách không bật số 0 ở cuối vòng lặp chính và hai byte khác bằng cách không đẩy số 0 khi bắt đầu, thay vào đó dựa vào phần đệm số 0 ở dưới cùng của ngăn xếp.

({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

Để biết giải thích cho chương trình chia số nguyên, hãy xem câu trả lời của frageum

Giải thích bộ phận Integer sắp ra mắt ...

Java 8, 18 byte

(a,b)->a/b+","+a%b

Đây là một biểu thức lambda của loại BiFunction<Integer, Integer, String>.

Tôi ngạc nhiên ... đây thực sự là một giải pháp khá súc tích cho Java. Đi biểu thức lambda!

Brain-Flak , 168 148 110 byte

Tôi đoán tôi nên kiểm tra Wiki trước

(({})(<({}(<(({})<>)>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<>)

Định dạng:

Input:    Output:
A (18)    remainder (2)
B (4)     division  (4)

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

(({})(<           # Copy A
({}(<             # Pick up A
(({})<>)          # Copy B to the other stack
>))               # Put A on top of a 0 on the second stack
                  # At this point the stacks look like this:   A
                                                               0
                                                             B B
                                                               ^

<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>) # Positive division from the wiki
>))                                          # Put down A on top of a 0
                                             # The stack now: A
                                                              0
                                                            Div B
                                                              ^

<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<>)     # Modulo from the wiki

sed, 36 byte

35 byte mã, +1 cho -rcờ.

:a;s/^(1+)( 1*)\1/\1\2x/;ta;s/.* //

Đưa đầu vào vào unary, phân tách không gian, với số nhỏ hơn trước. Đầu ra là unary, với thương số đầu tiên tính bằng 1s và phần còn lại thứ hai tính bằng xs. (Nếu điều này không được chấp nhận, hãy cho tôi biết và tôi sẽ thay đổi nó thành 1s được phân tách bằng dấu cách như đầu vào.)

Giải trình

:a;                                  Define label a
   s/            /     /;            Perform this substitution:
     ^(1+)                           Match the first unary number...
          ( 1*)                      ... followed by a space and 0 or more 1s...
               \1                    ... followed by the the first group again
                  \1\2x              Keep the first two parts unchanged; replace the third
                                     with an x
                         ta;         If the substitution succeeded, goto a
                            s/.* //  After the loop is over, remove the first number

Excel 2013, 31 30 26 byte

=INT(A1/B1)&","&MOD(A1;B1)

Giải trình

Đầu vào là trong ô A1và B1. Điều này chỉ đơn giản trả về các giá trị trả về của hàm FLOORvà MODhàm dành cho phần còn lại và phần còn lại. Các giá trị này được phân tách bằng dấu phẩy.

Python 2 , 20 byte

lambda a,b:(a/b,a%b)

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

Tích hợp, 6 byte

divmod

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

Thạch , 3 byte

:,%

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

DẦU , 134 106 103 102 byte

Lấy đầu vào từ stdin, hai số được phân tách bằng một dòng mới. Đưa ra kết quả của phép chia số nguyên, sau đó là một dòng mới và sau đó là phần còn lại.

Đây là một trong những chương trình DẦU phức tạp nhất mà tôi từng viết, vì OIL thiếu các phần xây dựng để phân chia, phần còn lại, bổ sung, phần nền, v.v. Nó hoạt động với cách phân chia nguyên thủy: lặp đi lặp lại lồng nhau.

Tôi trình bày mã theo định dạng chú thích, với các nhận xét theo kiểu ngôn ngữ kịch bản. Trước khi thực hiện, các ý kiến ​​phải được loại bỏ.

5  # read input into lines 0 and 2

5
2
0  # the zero to compare to (nops)
1  # make a backup of the second input at line 3
2
3
10 # check if the second input is 0. %
4
2
24 # if so, jump to 24 (marked with §)
13 # else, go on
10 # check if the first input is zero &
4

31 # if so, jump to 31 (marked with $)
18 # else, go on
9  # decrement both numbers

9
2
6  # jump to line 8 (marked with %)
8
8  # increment the value in line 1 (initially a zero) §
1
1  # "restore the backup"
3
2
6  # jump to line 13 (marked with &)
13
10 # is the second number zero? $
4
2
42 # if so, jump to 42 (marked with +)
36 # else go on
9  # decrement both the second number and the backup
2
9
3
6  # jump to 31 (marked with $)
31
4  # print the division +
1
11 # a newline
4
3  # and the remainder (from the backup)

chỉnh sửa: Đã cạo thêm 3 byte bằng cách di chuyển "hằng" sang vị trí một chữ số (ít byte hơn để tham chiếu), sau đó ẩn 2 vị trí 0 (Thay vào đó bằng cách sử dụng một dòng trống. trước).

chỉnh sửa: Và một byte khác bằng cách làm cho số 0 ban đầu ẩn. Chúng tôi thực sự chỉ cần một chữ số không.

Võng mạc , 14 byte

Hãy lạm dụng các định dạng đầu vào / đầu ra!

(.*)¶(\1)*
$#2

Lấy đầu vào là b\na, trong unary, sử dụng cho chữ số unary bất kỳ ký tự không chữ số, không dòng mới nào. Xuất ra thương số theo số thập phân, ngay sau đó là phần còn lại trong unary, sử dụng cùng ký tự với đầu vào.

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

(.*) ¶(\1)*khớp với số đầu tiên, sau đó là một dòng mới (là tốc ký của Retina cho \ n), sau đó là số đầu tiên nhiều lần nhất có thể. Số lượng các trận đấu của nhóm thứ hai sẽ là kết quả của sự phân chia và phần không khớp sẽ là phần còn lại.

Với $#2, chúng tôi thay thế mọi thứ phù hợp trong dòng trước bằng số lần chụp của nhóm thứ hai và nhận được kết quả của chúng tôi.

ArnoldC , 286 283 byte

HEY CHRISTMAS TREE c
YOU SET US UP 0
HEY CHRISTMAS TREE d
YOU SET US UP 0 
GET TO THE CHOPPER c
HERE IS MY INVITATION a
HE HAD TO SPLIT b
ENOUGH TALK
GET TO THE CHOPPER d
HERE IS MY INVITATION a
I LET HIM GO b
ENOUGH TALK
TALK TO THE HAND c
TALK TO THE HAND d
YOU HAVE BEEN TERMINATED

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

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

HEY CHRISTMAS TREE c      //DECLARE VARIABLE c = 0
YOU SET US UP 0
HEY CHRISTMAS TREE d      //DECLARE VARIABLE d = 0
YOU SET US UP 0

GET TO THE CHOPPER c      /*
HERE IS MY INVITATION a      SET c = a/b
HE HAD TO SPLIT b         
ENOUGH TALK                */

GET TO THE CHOPPER d      /*
HERE IS MY INVITATION a      SET d = a mod b
I LET HIM GO b
ENOUGH TALK                */

TALK TO THE HAND c        // PRINT c
TALK TO THE HAND d        // PRINT d
YOU HAVE BEEN TERMINATED  //END

Định dạng đầu ra

a/b
a mod b

Mê cung , 11 byte

?:?:}/!\{%!

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

Giải trình

?:   Read a and duplicate.
?:   Read b and duplicate.
}    Move a copy of b over to the auxiliary stage.
/    Compute a/b.
!    Print it.
\    Print a linefeed.
{    Get back the other copy of b.
%    Compute a%b.
!    Print it.

IP sau đó đi vào ngõ cụt, quay lại và chương trình chấm dứt do sự phân chia cố gắng bằng 0 khi %được thực hiện lại.

C, 32 byte

f(a,b){printf("%d %d",a/b,a%b);}

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

> <> , 27 26 16 + 1 = 17 byte

:r:{%:n','o-$,n;

chú thích

• Đầu vào sử dụng -v cờ, xem TIO để biết ví dụ.
• Điều này xuất ra phần còn lại trước, sau đó là dấu phẩy và cuối cùng là phép chia số nguyên.

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

Giải trình

Lưu ý rằng ngăn xếp bắt đầu là A, B, ở đâu Avà Bđại diện cho đầu vào thứ nhất và thứ hai, do -vcờ được sử dụng.

:r:{%:n','o-$,n; # Explanation
:r:{             # Do some stack modifications to prepare it for
                 #    next part
                 #    (Stack: B, A, A, B)
    %            # Take the modulo of the top two items
                 #    (Stack: B, A, A%B)
     :           # Duplicate it
                 #    (Stack: B, A, A%B, A%B)
      n          # Pop once and output as number
                 #    (Stack: B, A, A%B)
       ','o      # Print separator
                 #    (Stack: B, A, A%B)
           -     # Subtract the modulo from the first input
                 #    (Stack: B, A-A%B)
            $,   # Swap the two inputs so they are back in order
                 #     and divide, so we get an integer
                 #    (Stack: floor(A/B))
              n; # Output that as a number and finish.

C, 21 byte

#define f(a,b)a/b,a%b

Một macro thay thế f (a, b) bằng 2 dấu phẩy được phân tách. Mặc dù bạn tốt hơn nên chuyển nó đến một chức năng nếu không sẽ không có cách nào để chọn 2 cái này.

Dùng thử trực tuyến

Haskell , 21 byte

a#b=(div a b,mod a b)

Hãy thử trực tuyến!Ví dụ sử dụng: 13#2trả về (6,1). Vâng, điều này khá nhàm chán, tuy nhiên hơi thú vị hơndivMod tích hợp hoạt động tương tự.

Trong khi chúng ta đang ở đó, cũng có quot, remvà quotRemhành vi tương tự trên các số tự nhiên là div, modvà divMod. Tuy nhiên, đối với các đầu vào âm, kết quả của modcó cùng dấu với ước số, trong khi kết quả remcó cùng dấu với cổ tức. Hoặc, như được đưa vào tài liệu Prelude , quotlà phép chia số nguyên bị cắt về 0 và divlà phép chia số nguyên bị cắt cụt về vô cực âm.

Làm thế nào về không divhoặc modxây dựng?

Không có bản dựng, 36 32 31 byte

a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b

Hãy thử trực tuyến! Ví dụ sử dụng: 13#2trả về (1,6), đó là modkết quả đầu tiên và divkết quả thứ hai. Nếu anhỏ hơn b, thì a mod blà avà a div blà 0, vì vậy (a,0)được trả lại. Mặt khác tính toán đệ quy modvàdiv của a-b, và bthêm1 vào kết quả chia và giữ phần còn lại.

Thêm 1 vào kết quả phân chia đạt được bằng cách sử dụng <$> , thường được sử dụng mapđể ánh xạ các hàm qua danh sách, nhưng cũng hoạt động trên các bộ dữ liệu, tuy nhiên chức năng này chỉ được áp dụng cho phần tử bộ thứ hai.

Chỉnh sửa: Đã lưu một byte nhờ xnor!

SWI Prolog, 109 byte

p(A):-print(A).
d(F,S,0,F):-S>F.
d(F,S,D,R):-G is F-S,d(G,S,E,R),D is E+1.
d(F,S):-d(F,S,D,R),p(D),p(-),p(R).

Đầu ra:

?- d(255,25).
10-5
true .
?- d(5,7).
0-5
true .

Sự miêu tả:

Thuật toán đệ quy đơn giản mà không cần phân chia dựng sẵn hoặc modulo. Nó chỉ đơn giản là đếm "có bao nhiêu lần khớp số thứ hai vào số thứ nhất?" và báo cáo kết quả (thống nhất với D) với phần còn lại (R).

// chỉnh sửa: xóa các khoảng trống không cần thiết

Gol> <> , 11 byte

I:I:@$S,N%h

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

MATL, 5 byte

/k&G\

Dùng thử tại MATL Online!

Giải trình

        % Implicitly grab the two inputs as numbers
/       % Divide them
k       % Round down the result
&G      % Grab the two inputs again
\       % Compute the remainder

Ouroboros , 15 byte

r.r.@/Inao\%n1(

Lấy các số theo thứ tự ngược lại (ví dụ 10 42).Hãy thử nó ở đây.

Giải trình

r.r.             Read a number, duplicate, read a number, duplicate
    @            Rotate a copy of the first number to the top of the stack
     /I          Divide and truncate to integer
       n         Output as number
        ao       Push 10 and output as character (newline)
          \%     Swap the remaining two values and take the mod
            n    Output as number
             1(  Push 1 and swallow that many characters from the end of the program,
                 halting execution