Bài tập

Cho hai số nguyên dương Nghiêm n và d như đầu vào, xác định xem n là chia hết bởi d , tức là, nếu có tồn tại một số nguyên q như vậy n = qd.

Bạn có thể viết chương trình hoặc chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra.

Đầu ra phải là giá trị trung thực hoặc giả ; trung thực nếu n chia hết cho d và ngược lại.

Mã của bạn chỉ phải xử lý các số nguyên mà nó có thể biểu diễn nguyên bản, miễn là nó hoạt động với tất cả các số nguyên 8 bit đã ký. Tuy nhiên, thuật toán của bạn phải làm việc cho các số nguyên lớn tùy ý.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

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

 n,  d    output

 1,  1    truthy
 2,  1    truthy
 6,  3    truthy
17, 17    truthy
22,  2    truthy
 1,  2    falsy
 2,  3    falsy
 2,  4    falsy
 3,  9    falsy
15, 16    falsy

Bảng xếp hạng

Đoạn trích Stack ở cuối bài đăng này tạo ra danh mục từ các câu trả lời a) dưới dạng danh sách các giải pháp ngắn nhất cho mỗi ngôn ngữ và b) dưới dạng bảng xếp hạng tổng thể.

Để đả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ờ phiên dịch), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

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

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

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

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><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=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution 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> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 86149; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 48934; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Thạch , 1 byte

ḍ

Điều này khiến tôi mất nhiều giờ để chơi gôn.

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

Brain-Flak , 72 70 64 62 58 46 byte

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

Lấy cổ tức và số chia (theo thứ tự đó) làm đầu vào và in số chia (trung thực) hoặc không có gì. Vì mỗi ngăn xếp có một số 0 vô hạn, nên đầu ra trống nên được coi là giả.

Mặc dù không dọn dẹp ngăn xếp, giải pháp này chỉ sử dụng một ngăn xếp duy nhất.

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

Cảm ơn @WheatWizard vì đã chơi golf 2 byte!

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

                INPUT: a (dividend), b (divisor)
                INITIAL STACK: n = a, d = b, r = 0
                               An infinite amount of zeroes follows.

{               While n is non-zero:
  (
    {}              Pop n from the stack.
    [()]            Yield -1.
    {               While the top of the stack (initially, d) is non-zero:
      (<()>)          Push 0.
    }
    {}              Pop 0. This will remove d from the stack if d = 0, leaving r
                    on top. We can think of this as performing the assignment
                    (d, r) = (r, d) if d = 0.
    <
      (
        {}              Pop d.
        [()]            Yield -1.
        <
          (
            {}              Pop r.
            ()              Yield 1.
          )               Push r + 1.
        >               Yield 0.
      )               Push d + (-1) + 0 = d - 1.
    >               Yield 0.
  )               Push n + (-1) + 0 + 0 + 0 = n - 1.
}               Each iteration decrements n, swaps d and r if d = 0, decrements d,
                and increments r.
                FINAL VALUES: n = 0
                              d = b - r
                              r = a % b if a % b > 0 else b
{}              Pop n.
{               While the top of the stack is non-zero:
  {}              Pop it.
}               This pops d and r if d > 0 (and, thus, a % b > 0) or noting at all.
{}              Pop d or a 0, leaving r if r = b and, thus, a % b = 0.

Tính toán mô đun, 42 byte

Thay vào đó, chương trình đầy đủ ở trên có thể được sửa đổi một cách tầm thường để tính toán mô đun.

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

Như trước đây, phương thức này không phải là stack-clean, nhưng nó chỉ sử dụng một stack duy nhất. Một mô-đun 0 sẽ để trống ngăn xếp, tương đương với việc để lại 0 ; mỗi ngăn chứa số không vô hạn.

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

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

So sánh hai vòng lặp của máy kiểm tra khả năng phân chia và máy tính mô đun.

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

Sự khác biệt duy nhất là vị trí của {(<()>)}{}, mà hoán đổi d và r nếu d = 0 . Để tính mô-đun, chúng tôi thực hiện trao đổi này sau khi giảm d và tăng r .

Thay đổi này không ảnh hưởng đến kết quả nếu a% b> 0 , nhưng nếu a% b = 0 , nó sẽ rời khỏi (n, d, r) = (0, b, 0) - chứ không phải (n, d, r) = (0, 0, b) - trên ngăn xếp.

Vì vậy, để có được mô-đun, chúng ta chỉ phải bật n và d với {}{}.

Tính toán mô đun ngăn xếp sạch, 64 byte

Thuật toán mô đun 42 byte không phải là stack-clean, vì vậy nó không thể được sử dụng như trong tất cả các chương trình. Phiên bản sau đây sẽ chia cổ tức và ước số (theo thứ tự đó) từ ngăn xếp hoạt động và đẩy mô đun trở lại. Nó không có tác dụng phụ khác.

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

Giải pháp này chủ yếu dựa trên bản ghi 72 byte trước đây của @ WheatWizard, nhưng nó tiết kiệm 6 byte bằng cách không bao giờ chuyển đổi ngăn xếp.

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

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

             INPUT: a (dividend), b (divisor)
             INITIAL STACK: n = a, b

(
  {}         Pop and yield n = a.
  (<()>)       Push d = 0.
)              Push n + 0 = n.
             STACK: n, d = 0, b
{(           While n in non-zero:
  {}           Pop and yield n.
  [()]         Yield -1.
  <
   ((
     {}         Pop and yield d.
     ()         Yield 1.
     [({})]     Pop b, push it back on the stack, and yield -b.
   ))         Push d + 1 + -b = d + 1 - b twice.
   {          While/if d + 1 - b is non-zero, i.e., if d < b - 1
     {}         Pop d + 1 - b (second copy).
     (<(
       {}         Pop d + 1 - b (first copy).
       ({})       Pop b and push it back on the stack.
     )>)        Push d + 1 - b + b = d + 1, then 0.
   }          If the loop wasn't skipped entirely, pushing 0 breaks out.
              If d < b - 1, it essentially performs the assignment d = d + 1.
              However, if d = b - 1, we get d = d + 1 - b = b - 1 + 1 - b = 0.
              In all cases, we wind up with d = (d + 1) % b.
   {}         Pop 0.
  >         Yield 0.
)}        Push n + -1 + 0 = n - 1. Break if n - 1 = 0.
          STACK: n = 0, d = a % b, b
(
  {}        Pop and yield n = 0.
  {}        Pop and d = a % b.
  <{}>      Pop b, but yield 0.
)         Push 0 + a % b + 0 = a % b.

mã máy x86_32, 8 byte

08048550 <div7>:
 8048550:   99                      cdq   
 8048551:   f7 f9                   idiv   %ecx
 8048553:   85 d2                   test   %edx,%edx
 8048555:   0f 94 c0                sete   %al

Đây là câu trả lời golf mã đầu tiên của tôi, vì vậy hy vọng tôi tuân thủ tất cả các quy tắc.

Điều này đầu tiên gọi cdq để xóa thanh ghi edx, sau đó thực hiện phân chia đã ký trên thanh ghi ecx, lưu trữ phần còn lại trong edx. Dòng edx, edx sẽ kiểm tra cờ zero nếu edx bằng 0 và sete đặt 0 cho false nếu edx không bằng 0 và đặt 1 là true nếu edx bằng 0.

Đây chỉ là đoạn mã đóng góp vào số byte, nhưng để kiểm tra, đây là mã C tôi đã viết với cụm nội tuyến vì cách này dễ dàng hơn để xử lý I / O.

Lục giác, 15, 13, 12 10 byte

Ngôn ngữ dựa trên hình lục giác yêu thích của mọi người! : D

TL; DR hoạt động bằng ma thuật, các giải pháp chưa được định dạng trong việc giảm số byte:

?{?..>1'%<.@!'/
?{?!1\.'%<@.>
?{?\!1@'%\!(
?{?!1\@'%<

Đã lưu 2 byte nhờ trình hướng dẫn bố cục của @ MartinEnder.

@FryAmTheEggman đã lưu 1 byte bằng cách sử dụng các góc một cách sáng tạo hơn

Cả @MartinEnder và @FryAmTheEggman đã đưa ra một giải pháp 10 byte không in bất cứ thứ gì cho các giá trị giả.

Giải pháp của tôi (15):

Chưa được định dạng:

?{?..>1'%<.@!'/

Định dạng:

  ? { ?
 . . > 1
' % < . @
 ! ' / .
  . . .

Giải pháp của @Martin Ender (13):

Chưa được định dạng:

?{?!1\.'%<@.>

Định dạng:

  ? { ?
 ! 1 \ .
' % < @ .
 > . . .
  . . .

Giải trình:

Đầu tiên, chúng ta nhận được đầu vào và lấy mô-đun.

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

Sau đó, nó kiểm tra xem mô đun có bằng 0 hay không. Nếu đúng, IP quay trái 60 độ, bật ra khỏi gương, đặt ô thành 1 và in.

Sau đó, IP tiếp tục lên hàng thứ tư. Khi đến được >, nó sẽ quay sang bên phải (vì giá trị của ô bây giờ là 1). Nó đi oob, và quay trở lại ở góc dưới bên phải hướng về phía Tây Bắc. IP chạm vào <, đi dọc theo hàng trên cùng và quay lại ở góc bên phải để nhấn @, dừng chương trình.

  . . .
 ! 1 \ .
. . < @ .
 > . . .
  . . .

Nếu mô đun hóa ra là dương, IP quay 60 độ sang phải. Khi nó đi ra góc dưới bên phải, nó tiếp tục ở cạnh dưới bên trái vì các quy tắc gói của Hexagony. Việc 'này được tái sử dụng để làm cho IP đi đến một ô có 0 trong đó. IP sau đó di chuyển dọc theo hàng thứ tư, quấn quanh đến hàng thứ hai, chạm vào bản in và được phản ánh vào <. Phần còn lại của con đường đến @là như nhau.

  . . .
 ! . \ .
' . < @ .
 > . . .
  . . .

Đó là một số phù thủy nghiêm túc.

@ FryAmTheEggman's Solution (12):

Chưa được định dạng:

?{?\!1@'%\!(

Định dạng:

  ? { ?
 \ ! 1 @
' % \ ! (
 . . . .
  . . .

Giải trình:

Giống như các giải pháp khác, nó nhận đầu vào và lấy mô-đun.

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

Sau đó, IP bị lệch vào góc dưới cùng. Nếu mô đun là dương, nó đi ở cạnh trên bên trái. Không ?có thêm đầu vào, vì vậy nó đặt ô thành 0. Sau !đó in 0 và @kết thúc chương trình.

  ? . .
 \ ! . @
. . \ . .
 . . . .
  . . .

Mọi thứ phức tạp hơn nhiều khi mô đun bằng 0. Trước hết, nó được giảm dần, sau đó đặt lại về 0, sau đó đặt thành 1, sau đó in. Sau đó, 1 được giảm xuống còn 0. Sau đó, chương trình chạy như lúc ban đầu cho đến khi nó cố gắng thực hiện 0%0. Điều đó làm cho nó ném một lỗi im lặng và bỏ.

  ? { ?
 . . 1 .
' % \ ! (
 . . . .
  . . .

Tôi thực sự thích thủ thuật lỗi im lặng, nhưng một cách đơn giản hơn là thay thế (bằng /IP để lần đầu tiên đi qua, nhưng lại bị phản ánh vào @lần thứ hai.

Giải pháp hợp tác (10):

Chưa được định dạng:

?{?!1\@'%<

Định dạng:

  ? { ?
 ! 1 \ @
' % < . .
 . . . .
  . . .

Chương trình này bắt đầu giống như tất cả các chương trình khác, nhận đầu vào và sửa đổi nó.

Nếu đầu vào là 0, IP sẽ rẽ trái khi chạm <. Nó bị lệch vào 1!@, in 1 và thoát.

  . . .
 ! 1 \ @
. . < . .
 . . . .
  . . .

Nếu đầu vào là dương, IP sẽ rẽ phải khi chạm <. Nó thoát ra qua góc và đi dọc theo cạnh trên bên phải, chạm vào @ mà không in.

  . . ?
 . . . @
. . < . .
 . . . .
  . . .

Brain-flak 102, 98, 96 byte

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

Ồ Tổng. Tôi có thể đăng một lời giải thích, nhưng tôi hầu như không hiểu nó. Ngôn ngữ này làm tổn thương não của tôi.

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

Cảm ơn người dùng github @Wheatwizard đã đưa ra một ví dụ mô-đun. Tôi có lẽ không thể tự mình tìm ra điều đó!

Ngoài ra, câu trả lời ngắn hơn là ở đây .

Có thể giải thích không chính xác:

(({}<>))                    #Push this element onto the other stack
<>                          #Move back to stack one.
{                           #While the top element is non-zero:
 ({}[()])                   #  Decrement the number on top
 <>                         #  Move to the other stack
 (({}[()]))                 #  Push the top element minus one twice
 {                          #  While the top element is non-zero:
  {}                        #    Pop the top element
  (<          >)            #    Push a zero
        ({})                #    Push the second from top element
       [    ]               #    Evalue this second from top element as negative
    ({}      )              #    And push that negative plus the top element
 }
 {}                         #  Pop the top element
 ({}({}))                   #  Push the top element plus the second from the top, AND push the second from top
 <>                         #  Switch stacks
}

{}                          #Pop the stack
<>                          #Switch to the other stack
([{}]{})                    #And push the top element minus the second element.

Phần còn lại là khá đơn giản.

{              }            #While the top element is non-zero:
 <>                         #Move to the other stack
   (([()])  )               #Push a negative one
          ()                #AND push the previously pushed value + 1 (e.g. 0)

                 (      )   #Push:
                  {}{}      #The top two elements added together
                      ()    #Plus one

Javascript (ES6) 17 12 11 byte

a=>b=>a%b<1

• EDIT: Đã xóa 5 byte vì 'a> 0' được mong đợi.
• EDIT2: Đã xóa 1 byte nhờ vào Downgoat .

Vim, 11 tổ hợp phím

C<C-r>=<C-r>"<C-Left>%<C-Right><1<cr>

Không tệ cho một ngôn ngữ chỉ xử lý các chuỗi. : D

Toán học - 17 13 3 byte

∣

Cảm ơn @MartinEnder vì đã tiết kiệm được rất nhiều byte!

Võng mạc, 12 byte

^(1+)\1* \1$

Đưa đầu vào được phân tách bằng dấu cách trong unary, muốn 111111111111 1111kiểm tra xem 12 nếu chia hết cho 4 . In 1 (đúng) hoặc 0 (sai).

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

FryAmTheEggman đã lưu hai byte. Rất tiếc, viết lại câu trả lời của tôi để đưa các đối số theo đúng thứ tự. (Sau đó, Fry đánh bại tôi trong phần bình luận. Tôi chậm ở regex!)

Mẻ, 20 byte

@cmd/cset/a!(%1%%%2)

Đầu ra 1thành công, 0thất bại.

C #, 27 13 12 byte

a=>b=>a%b<1;

Cảm ơn TuukkaX đã chỉ ra lambdas ẩn danh được chấp nhận. Cảm ơn David Conrad vì đã chỉ cho tôi món cà ri mà tôi thậm chí không biết là một thứ.

Ngắn gọn và ngọt ngào, vì chúng ta chỉ giao dịch với các số nguyên mà chúng ta có thể sử dụng <1chứ không phải ==0và lưu toàn bộ một byte.

Brainfuck, 53 byte

Lấy đầu vào là byte, đầu ra là giá trị byte của 0x00hoặc 0x01. Đó là thuật toán DivMod theo sau là phủ định Boolean .

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

Dùng thử trực tuyến - Có một loạt các phụ+ở gần cuối để bạn có thể thấy đầu ra trong ASCII.

Brain-Flak , 88 86 byte

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

Đây là phiên bản dày đặc hơn của thuật toán kiểm tra khả năng phân chia ban đầu của Brain-Flak được viết bởi Dr Green Eggs và Iron Man DJMcMayhem và bản thân tôi.

Dưới đây là một lời giải thích ngắn gọn (ish) về cách thức hoạt động của nó:

  ({}<>)        #Move the top of the stack to the other stack #Start Mod
(<      >)      #Push zero
<>              #Switch stacks
{               #While the top of the stack is not zero
 ({}[()])       #Subtract one from the top of the stack
 <>             #Switch stacks
   {}()         #Pop the top, add one and ...
       [({})]   #Subtract the second element on the stack
 ((          )) #Push twice
 {              #If the top is not zero
  {}            #Pop the duplicate
    ({}({}))    #Add the second element to the first
  (<        >)  #Push zero
 }              #End if
 {}             #Pop the zero
 <>             #Switch back
}               #End While
<>              #Switch to the other stack
 ({}<{}>)       #Remove the second value on the stack         #End Mod
(        )      #Duplicate the result of modulation
{               #If the top is not zero
 {}{}           #Pop the top two elements
 (<(())>)       #Push a one and a zero
}               #End if
{}              #Pop the zero

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

LOLCODE, 74 64 byte

HOW IZ I f YR a AN YR b
BOTH SAEM MOD OF a AN b AN 0
IF U SAY SO

C, 60 byte

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}

APL Dyalog , 3 byte

0=|

Là số không bằng phần còn lại của phân chia?

R, 22 20 byte

a=scan();!a[1]%%a[2]

Như thường lệ, đọc hai số từ đầu vào được kết thúc bởi một dòng trống.

Cập nhật: cảm ơn Jarko Dubbeldam vì đã loại bỏ 2 byte (mặc dù thực tế là chỉnh sửa của anh ta đã bị từ chối, nhưng nó rất hữu ích!).

Java 8, 11 byte

a->b->a%b<1

Cái quái gì vậy, có phiên bản JS và C # này, tại sao không phải là phiên bản Java?

Sử dụng:

import java.util.function.Function;

public class Program {
    public static void main(String[] args) {
        System.out.printf("%d, %d %b%n", 9, 3, divides(9, 3, a->b->a%b<1));
        System.out.printf("%d, %d %b%n", 3, 9, divides(3, 9, a->b->a%b<1));
    }

    public static boolean divides(int a, int b,
            Function<Integer, Function<Integer, Boolean>> f) {
        return f.apply(a).apply(b);
    }
}

Python, 16 byte

lambda D,d:D%d<1

GolfScript, 3 byte

~%!

Giải trình:

~    # Evaluate the input
 %   # Take the first modulus the second
  !  # Boolean not

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

CJam, 6 4 byte

Đã lưu 2 byte nhờ Dennis

q~%!

Dùng thử trực tuyến

q    e# Take in the input
 ~   e# Dump the individual values to the stack
  %  e# Modulus
   ! e# Boolean NOT

Brachylog , 2 byte

%0

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

Julia, 9 byte

D\d=D%d<1

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

Fortran 95, 78 byte

function f(i,j)result(k)
integer::i,j,k
k=merge(1,0,MOD(i,j)<1)
end function f

MarioLANG, 121 109 107 byte

Đã lưu 14 byte nhờ Martin Ender

;>(-)-)+(([!)
)"=========#[
; +(![-)< )<!+
  ==#==="  "#:
>!< >(+ !![(<
=#"="===##=:"
  !      <
  #======"

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

Giải trình

Thuật toán đơn giản chỉ là để giữ trừ dtừ nđể xem nếu bạn có thể làm điều đó một số nguyên lần và không có dư.

;
)
;

>
=
 
 

Đầu tiên, đầu vào được thu thập. nlà trong ô đầu tiên, dtrong ô thứ hai.

 >(-)-)+(([!
 "=========#
          )<
           "
 !
 #"="===##=
  
  

Đây thực chất là vòng lặp chính. Nó giảm các ô thứ nhất và thứ hai, và tăng thứ ba.

           [!)
           =#[
             !+
             #:
            (<
            :"
 
 

Đây là đầu ra cuối cùng. Nếu sau khi tăng / giảm, ô đầu tiên là 0, thì chúng ta đã loại bỏ n. Nếu sau này, ô thứ hai ( d) là 0, sau đó dđi vào nđồng đều. Chúng tôi tăng và in ( 1). Nếu không, di chuyển trở lại ô đầu tiên (đó là 0) và in nó.

 
 
  +(![-)<  
  ==#==="  
 !< >(+ !![
 #"="===##=
  !      <
  #======"

Vòng lặp này xảy ra nếu ô thứ hai là 0sau khi tăng và giảm. Nó sao chép ô thứ ba sang ô thứ hai. Phần ở phía dưới là bỏ qua vòng lặp nếu ô không 0.

Tcl, 34 byte

ge stdin a
ge stdin b
exp $a%$b<1

Lần thử đầu tiên / * thành công * / của tôi trong codegolf! Mã này phải được thực thi trong Tcl shell, nếu không nó sẽ không hoạt động.

Một byte nhờ @Lynn.

Bốn byte nhờ @Lynn và @LeakyNun (bây giờ tôi hiểu ý của anh ấy)!

PHP, 23 22 byte

<?=$argv[1]%$argv[2]<1

in 1 cho đúng, chuỗi rỗng (= nothing) cho false

gọi từ cli với nvà dnhư là đối số

10 byte cho PHP cổ đại: <?=$n%$d<1

J, 3 byte

0=|

Sử dụng:

2 (0=|) 10 

Sẽ trở lại 1. Và tương đương với mã giả10 MOD 2 EQ 0

Lưu ý rằng điều này rất giống với câu trả lời của APL , bởi vì J được lấy cảm hứng từ APL

PowerShell v2 +, 20 byte

!($args-join'%'|iex)

Đưa đầu vào thành hai đối số dòng lệnh $args, -joinkết hợp chúng thành một chuỗi với %dấu phân cách, các đường dẫn đến iex(viết tắt Invoke-Expressionvà tương tự eval). Kết quả là một 0hoặc không bằng 0, vì vậy chúng tôi lấy Boolean không phải !là kết quả đó, có nghĩa là $TRUEhoặc $FALSE(số nguyên khác không trong PowerShell là trung thực). Boolean đó được để lại trên đường ống và đầu ra là ẩn.

Các phiên bản thay thế, cũng có 20 byte mỗi

param($a,$b)!($a%$b)
!($args[0]%$args[1])

Cùng một khái niệm, chỉ là những cách khác nhau về cấu trúc đầu vào. Cảm ơn @DarthTwon đã cung cấp những thứ này.

Ví dụ

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 12
True

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 13
False

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 12 24
False

Haskell, 13 11 byte

((1>).).mod

Điều này xác định một chức năng mới (!) :: Integral n => n -> n -> Bool. Vì mod n mchỉ trả về số dương nếu nvà mlà số dương, chúng ta có thể lưu một byte bằng cách sử dụng 1>thay vì 0==.

Sử dụng:

ghci> let n!d=1>mod n d
ghci> 100 ! 2
True
ghci> 100 ! 3
False