Tugas

Diberikan dua bilangan bulat positif n dan d sebagai input, tentukan apakah n dapat dibagi habis oleh d , yaitu, jika ada bilangan bulat q sedemikian rupa sehingga n = qd.

Anda dapat menulis program atau fungsi dan menggunakan salah satu metode standar kami untuk menerima input dan memberikan output.

Outputnya harus berupa nilai true atau falsy ; benar jika n dapat dibagi oleh d , dan sebaliknya falsy.

Kode Anda hanya harus menangani bilangan bulat yang dapat diwakilinya secara asli, asalkan berfungsi untuk semua bilangan bulat 8-bit yang ditandatangani. Namun, algoritme Anda harus berfungsi untuk bilangan bulat besar yang sewenang-wenang.

Anda dapat menggunakan bahasa pemrograman apa pun , tetapi perhatikan bahwa celah ini dilarang secara default.

Ini adalah kode-golf , sehingga jawaban terpendek yang valid - diukur dalam byte - menang.

Uji kasus

 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

Papan peringkat

Cuplikan Stack di bagian bawah posting ini menghasilkan katalog dari jawaban a) sebagai daftar solusi terpendek per bahasa dan b) sebagai leaderboard keseluruhan.

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

## Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda dapat menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya adalah angka terakhir di tajuk:

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

Anda juga dapat membuat nama bahasa menjadi tautan yang kemudian akan muncul di cuplikan:

## [><>](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>

Jelly , 1 byte

ḍ

Ini membuat saya berjam-jam bermain golf.

Cobalah online!

Brain-Flak , 72 70 64 62 58 46 byte

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

Mengambil dividen dan pembagi (dalam urutan itu) sebagai input dan mencetak pembagi (benar) atau tidak sama sekali. Karena setiap tumpukan memiliki angka nol implisit, nol, output kosong harus dianggap palsu.

Meskipun tidak stack-clean, solusi ini hanya menggunakan satu stack.

Cobalah online!

Terima kasih kepada @WheatWizard untuk bermain golf 2 byte!

Bagaimana itu bekerja

                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.

Perhitungan modulus, 42 byte

Program lengkap di atas dapat dimodifikasi secara sepele untuk menghitung modulus saja.

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

Seperti sebelumnya, metode ini bukan stack-clean, tetapi hanya menggunakan satu stack. Modulus 0 akan membiarkan stack kosong, yang kira-kira setara dengan meninggalkan 0 ; setiap tumpukan berisi nol tanpa batas.

Cobalah online!

Bagaimana itu bekerja

Bandingkan dua loop dari tester keterbagian dan kalkulator modulus.

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

Satu-satunya perbedaan adalah lokasi {(<()>)}{}, yang menukar d dan r jika d = 0 . Untuk menghitung modulus, kami melakukan swap ini setelah menurunkan d dan menambah r .

Perubahan ini tidak mempengaruhi hasil jika a% b> 0 , tetapi jika a% b = 0 , ia meninggalkan (n, d, r) = (0, b, 0) - daripada (n, d, r) = (0, 0, b) - di tumpukan.

Jadi, untuk mendapatkan modulus, kita hanya perlu pop n dan d dengan {}{}.

Perhitungan modulus stack-clean, 64 byte

Algoritma modulus 42-byte bukanlah stack-clean, sehingga tidak dapat digunakan seperti pada semua program. Versi berikut muncul dividen dan pembagi (dalam urutan itu) dari tumpukan aktif dan mendorong modulus sebagai imbalan. Tidak memiliki efek samping lain.

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

Solusi ini sebagian besar didasarkan pada catatan 72-byte @ WheatWizard sebelumnya, tetapi menghemat 6 byte dengan tidak pernah mengganti tumpukan.

Cobalah online!

Bagaimana itu bekerja

             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.

kode mesin 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

Ini adalah jawaban golf kode pertama saya, jadi semoga saya mengikuti semua aturan.

Ini pertama kali memanggil cdq untuk menghapus register edx, kemudian melakukan pembagian yang ditandatangani pada register ecx, yang menyimpan sisanya di edx. Tes edx, garis edx akan mengatur bendera nol jika edx adalah nol, dan sete menempatkan 0 untuk false jika edx tidak nol, dan menempatkan 1 untuk true jika edx adalah 0.

Ini hanya potongan kode yang memberikan kontribusi terhadap jumlah byte, tetapi untuk pengujian, di sini adalah kode C yang saya tulis dengan inline perakitan karena lebih mudah dengan cara ini untuk menangani I / O.

Hexagony, 15, 13, 12 10 byte

Bahasa berbasis segi enam favorit semua orang! : D

TL; DR bekerja menggunakan sulap, solusi yang tidak diformat dalam mengurangi jumlah byte:

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

Disimpan 2 byte berkat layout layout @ MartinEnder.

@FryAmTheEggman menghemat 1 byte dengan menggunakan sudut-sudut yang lebih kreatif

@MartinEnder dan @FryAmTheEggman menghasilkan solusi 10 byte yang tidak mencetak apa pun untuk nilai palsu.

Solusi saya (15):

Tidak diformat:

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

Diformat:

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

Solusi @Martin Ender (13):

Tidak diformat:

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

Diformat:

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

Penjelasan:

Pertama, kami mendapatkan input dan mengambil modulus.

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

Kemudian, ia memeriksa apakah modulusnya 0 atau tidak. Jika ya, IP berubah 60 derajat ke kiri, memantul dari cermin, mengatur sel menjadi 1 dan mencetak.

Kemudian, IP berlanjut ke baris keempat. Saat mencapai >, alih-alih berbelok ke kanan (karena nilai sel sekarang 1). Itu berjalan oob, dan kembali di sudut kanan bawah menuju NW. IP mengenai <, pergi di sepanjang baris atas, dan kembali di sudut kanan untuk menekan @, menghentikan program.

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

Jika modulus berubah menjadi positif, IP berubah 60 derajat ke kanan. Setelah keluar sudut kanan bawah, itu berlanjut di tepi kiri bawah karena aturan pembungkus Hexagony. The 'digunakan kembali untuk membuat IP pergi ke sel dengan 0 di dalamnya. IP kemudian melakukan perjalanan di sepanjang baris keempat, membungkus ke yang kedua, mencetak hit, dan tercermin ke dalam <. Sisa jalan menuju @sama.

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

Itu sihir yang serius.

@ Solusi FryAmTheEggman (12):

Tidak diformat:

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

Diformat:

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

Penjelasan:

Seperti solusi lain, itu mendapat input dan mengambil modulus.

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

Kemudian, IP dibelokkan ke sudut bawah. Jika modulus positif, ia berada di tepi kiri atas. Tidak ?memiliki input lagi, sehingga mengatur sel ke 0. !Kemudian mencetak 0, dan @mengakhiri program.

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

Hal-hal yang jauh lebih sulit ketika modulus adalah 0. Pertama-tama, ia akan dikurangi, kemudian reset ke 0, kemudian atur ke 1, kemudian dicetak. Kemudian, angka 1 dikurangi menjadi 0. Setelah itu, program berjalan seperti pada awalnya sampai ia mencoba melakukannya 0%0. Itu membuatnya membuang kesalahan diam dan berhenti.

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

Saya sangat suka trik kesalahan diam, tetapi cara yang lebih sederhana adalah dengan mengganti (dengan /sehingga IP melewati pertama kali, tetapi akan tercermin ke @dalam yang kedua.

Solusi kolaboratif (10):

Tidak diformat:

?{?!1\@'%<

Diformat:

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

Program ini dimulai sama dengan semua program lain, mendapatkan input dan memodifikasinya.

Jika inputnya 0, IP berbelok ke kiri saat hits <. Itu akan dibelokkan ke dalam 1!@, yang mencetak 1 dan berhenti.

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

Jika input positif, IP berbelok ke kanan saat hits <. Keluar melalui sudut, dan berjalan di sepanjang tepi kanan atas menekan @ tanpa mencetak.

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

Brain-flak 102, 98, 96 byte

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

Eww. Kotor. Saya mungkin memposting penjelasan, tetapi saya sendiri hampir tidak memahaminya. Bahasa ini menyakiti otak saya.

Cobalah online!

Terima kasih kepada pengguna github @Wheatwizard untuk datang dengan contoh modulus. Saya mungkin tidak bisa mengetahuinya sendiri!

Juga, jawaban yang lebih pendek ada di sini .

Penjelasan yang mungkin salah:

(({}<>))                    #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.

Sisanya cukup mudah.

{              }            #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: Dihapus 5 byte karena 'a> 0' diharapkan.
• EDIT2: Dihapus 1 byte berkat Downgoat .

Vim, 11 penekanan tombol

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

Tidak buruk untuk bahasa yang hanya menangani string. : D

Mathematica - 17 13 3 byte

∣

Terima kasih kepada @MartinEnder karena menghemat satu ton byte!

Retina, 12 byte

^(1+)\1* \1$

Membawa input yang dipisahkan ruang dalam unary, ingin 111111111111 1111memeriksa apakah 12 jika dapat dibagi 4 . Mencetak 1 (benar) atau 0 (salah).

Cobalah online!

FryAmTheEggman menyimpan dua byte. Ups, tulis ulang jawaban saya untuk mengambil argumen dengan urutan yang benar. (Kemudian Fry mengalahkan saya dalam komentar. Saya lambat di regex!)

Batch, 20 byte

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

Keluaran 1pada kesuksesan, 0kegagalan.

C #, 27 13 12 Bytes

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

Terima kasih kepada TuukkaX karena menunjukkan lambda anonim dapat diterima. Terima kasih kepada David Conrad karena telah menunjuk saya pada kari yang bahkan tidak saya sadari adalah suatu hal.

Singkat dan manis, karena kita hanya berurusan dengan bilangan bulat yang bisa kita gunakan <1alih-alih ==0dan menyimpan seluruh byte.

brainfuck, 53 byte

Mengambil input sebagai byte, output adalah nilai byte 0x00atau 0x01. Ini adalah algoritma DivMod yang diikuti oleh negasi Boolean .

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

Cobalah online - Memiliki banyak tambahan+di akhir sehingga Anda dapat melihat output di ASCII.

Brain-Flak , 88 86 byte

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

Ini adalah versi yang lebih padat dari algoritme uji keterbelahan Brain-Flak asli ditulis oleh keterbagian Dr Green Eggs dan Iron Man DJMcMayhem dan saya sendiri.

Berikut ini penjelasan singkat tentang cara kerjanya:

  ({}<>)        #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

Cobalah secara Online!

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 Bytes

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

Dyalog APL , 3 byte

0=|

Apakah nol sama dengan sisa divisi?

R, 22 20 byte

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

Seperti biasa, membaca dua angka dari input yang diakhiri oleh baris kosong.

Perbarui: terima kasih Jarko Dubbeldam karena mencukur 2 byte (walaupun fakta bahwa editnya ditolak, itu sangat membantu!).

Java 8, 11 byte

a->b->a%b<1

Apa sih, ada versi JS dan C # ini, mengapa bukan versi Java juga?

Pemakaian:

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

~%!

Penjelasan:

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

Cobalah online!

CJam, 6 4 byte

Disimpan 2 byte berkat Dennis

q~%!

Cobalah online

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

Brachylog , 2 byte

%0

Cobalah online!

Julia, 9 byte

D\d=D%d<1

Cobalah online!

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

Disimpan 14 byte berkat Martin Ender

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

Cobalah online!

Penjelasan

Algoritma ini hanya untuk terus mengurangi ddari nuntuk melihat apakah Anda dapat melakukannya berkali-kali dan tidak memiliki sisa.

;
)
;

>
=
 
 

Pertama, input dikumpulkan. nada di sel pertama, ddi kedua.

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

Ini pada dasarnya adalah loop utama. Ini mengurangi sel pertama dan kedua, dan meningkatkan ketiga.

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

Ini adalah hasil akhir. Jika setelah kenaikan / penurunan, sel pertama adalah 0, maka kami telah menghilangkannya n. Jika setelah ini, sel kedua ( d) adalah 0, kemudian dmasuk nsecara merata. Kami menambah dan mencetak ( 1). Kalau tidak, kembali ke sel pertama (yang 0) dan cetak.

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

Perulangan ini terjadi jika sel kedua 0setelah kenaikan dan penurunan. Ini menyalin sel ketiga ke sel kedua. Bagian di bawah adalah untuk memotong loop jika sel tidak 0.

Tcl, 34 byte

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

Usaha saya yang pertama / * * sukses / di codegolf! Kode ini harus dieksekusi di shell Tcl, jika tidak maka tidak akan berfungsi.

Satu byte terima kasih kepada @Lynn.

Empat byte terima kasih kepada @Lynn dan @LeakyNun (sekarang saya mengerti apa yang dia maksud)!

PHP, 23 22 byte

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

mencetak 1 untuk string benar, kosong (= tidak ada) untuk false

panggilan dari cli dengan ndan dsebagai argumen

10 byte untuk PHP kuno: <?=$n%$d<1

J, 3 byte

0=|

Pemakaian:

2 (0=|) 10 

Akan kembali 1. Dan sama dengan pseudocode10 MOD 2 EQ 0

Perhatikan ini sangat mirip dengan jawaban APL , karena J sangat terinspirasi oleh APL

PowerShell v2 +, 20 byte

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

Dibawa input sebagai dua argumen baris perintah $args, -joins mereka bersama-sama menjadi string dengan %sebagai pemisah, pipa itu ke iex(kependekan dari Invoke-Expressiondan mirip dengan eval). Hasilnya adalah salah 0atau tidak nol, jadi kami mengambil Boolean bukan !dari hasil itu, yang berarti salah satu $TRUEatau$FALSE (bilangan bulat nol di PowerShell benar). Bahwa Boolean ditinggalkan di jalur pipa dan hasilnya tersirat.

Versi alternatif, juga masing-masing 20 byte

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

Konsep yang sama, hanya sedikit cara penataan input yang berbeda. Terima kasih kepada @DarthTwon untuk menyediakan ini.

Contohnya

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

Ini mendefinisikan fungsi baru (!) :: Integral n => n -> n -> Bool. Karena mod n mmengembalikan hanya angka positif jika ndan mpositif, kita dapat menyimpan byte dengan menggunakan 1>alih-alih 0==.

Pemakaian:

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