Test di divisibilità

39

Compito

Dati due numeri interi strettamente positivi n e d come input, determinare se n è equamente divisibile per d , ovvero se esiste un intero q tale che n = qd.

È possibile scrivere un programma o una funzione e utilizzare uno dei nostri metodi standard per ricevere input e fornire output.

L'output dovrebbe essere un valore di verità o di falsità ; verità se n è divisibile per d , e falsa altrimenti.

Il tuo codice deve solo gestire numeri interi che può rappresentare in modo nativo, purché funzioni per tutti i numeri interi a 8 bit con segno. Tuttavia, il tuo algoritmo deve funzionare per numeri interi arbitrariamente grandi.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Casi test

 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

Classifica

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

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

Mostra snippet di codice

code-golf  math  arithmetic  decision-problem  division 
— Perdente Suora
fonte
Questa conversazione è stata spostata in chat .
— Dennis,

Risposte:

29

Brain-Flak , 72 70 64 62 58 46 byte

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

Prende dividendo e divisore (in quell'ordine) come input e stampa il divisore (verità) o niente. Poiché ogni stack ha una quantità implicita e infinita di zeri, l'output vuoto deve essere considerato errato.

Pur non essendo impilabile, questa soluzione utilizza solo un singolo stack.

Provalo online!

Grazie a @WheatWizard per giocare a golf da 2 byte!

Come funziona

                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.

Calcolo del modulo, 42 byte

Il programma completo sopra può essere modificato in modo banale per calcolare invece il modulo.

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

Come prima, questo metodo non è pulito dallo stack, ma utilizza solo uno stack. Un modulo di 0 lascerà vuoto lo stack, che equivale all'incirca a lasciare 0 ; ogni pila contiene zero infiniti.

Provalo online!

Come funziona

Confronta i due loop del tester di divisibilità e del calcolatore del modulo.

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

L'unica differenza è la posizione di {(<()>)}{}, che scambia d e r se d = 0 . Per calcolare il modulo, eseguiamo questo scambio dopo aver ridotto d e aumentato r .

Questa modifica non influisce sul risultato se a% b> 0 , ma se a% b = 0 , lascia (n, d, r) = (0, b, 0) - anziché (n, d, r) = (0, 0, b) - in pila.

Quindi, per ottenere il modulo, dobbiamo solo pop n e d con {}{}.

Calcolo del modulo impilabile, 64 byte

L'algoritmo del modulo a 42 byte non è pulito dallo stack, quindi non può essere utilizzato come in tutti i programmi. La seguente versione estrae dividendo e divisore (in quell'ordine) dallo stack attivo e spinge il modulo in cambio. Non ha altri effetti collaterali.

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

Questa soluzione si basa in gran parte sul precedente record di 72 byte di @ WheatWizard, ma consente di risparmiare 6 byte senza mai cambiare stack.

Provalo online!

Come funziona

             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.
— Dennis
fonte
20

codice macchina 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

Questa è la mia prima risposta in codice golf, quindi spero di seguire tutte le regole.

Questo prima chiama cdq per cancellare il registro edx, quindi esegue la divisione firmata sul registro ecx, che memorizza il resto in edx. Il test edx, la linea edx imposterà il flag zero se edx è zero, e sete mette uno 0 per falso se edx non era zero e mette un 1 per vero se edx era 0.

Questo è solo lo snippet di codice che contribuisce al conteggio dei byte, ma per il test, ecco il codice C che ho scritto con l'assembly inline perché è più semplice gestire l'I / O in questo modo.

— davey
fonte
2
Benvenuto in PPCG, bella prima risposta!
— Leaky Nun,
Deve essere un programma completo? Stavo formattando la mia risposta in qualche modo da questa risposta . E grazie! Spero di migliorare il codice assembly / machine per giocare a golf con il codice!
— davey,
1
L'input e l'output nei registri specificati nell'assembly sono consentiti per impostazione predefinita: input , output . Questa è una proposta perfettamente accettabile. Benvenuti in PPCG!
— Mego
Fantastico! Grazie!
— davey,
17

Esagonia, 15, 13, 12 10 byte

Il linguaggio esagonale preferito da tutti! : D

TL; DR funziona usando soluzioni magiche e non formattate nel conteggio decrescente di byte:

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

Salvato 2 byte grazie alla procedura guidata di layout di @ MartinEnder.

@FryAmTheEggman ha salvato 1 byte usando gli angoli in modo più creativo

Sia @MartinEnder che @FryAmTheEggman hanno escogitato una soluzione da 10 byte che non stampa nulla per valori errati.

La mia soluzione (15):

non formattato:

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

formattato:

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

@Martin Ender's Solution (13):

non formattato:

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

formattato:

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

Spiegazione:

Innanzitutto, otteniamo l'input e prendiamo il modulo.

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

Quindi, controlla se il modulo è 0 o no. In tal caso, l'IP gira a 60 gradi a sinistra, rimbalza dallo specchio, imposta la cella su 1 e stampa.

Quindi, l'IP continua sulla quarta riga. Quando raggiunge il >, invece, gira a destra (perché il valore della cella è ora 1). Si spegne e ritorna nell'angolo in basso a destra in direzione NW. L'IP colpisce il <, va lungo la riga superiore e ritorna nell'angolo destro per colpire @, arrestando il programma.

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

Se il modulo risulta positivo, l'IP gira di 60 gradi verso destra. Una volta che esce dall'angolo in basso a destra, continua sul bordo in basso a sinistra a causa delle regole di avvolgimento di Hexagony. La 'viene riutilizzato per rendere l'IP andare in una cella con 0 in esso. L'IP quindi viaggia lungo la quarta fila, si avvolge fino alla seconda, colpisce la stampa e si riflette nella <. Il resto del percorso verso @lo stesso è lo stesso.

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

Questo è un grave incantesimo.

@ FryAmTheEggman's Solution (12):

non formattato:

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

formattato:

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

Spiegazione:

Come le altre soluzioni, ottiene l'input e accetta il modulo.

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

Quindi, l'IP viene deviato nell'angolo inferiore. Se il modulo è positivo, va sul bordo superiore sinistro. Non ?ha più input, quindi imposta la cella su 0. !Quindi stampa lo 0 e @termina il programma.

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

Le cose sono molto più complicate quando il modulo è 0. Innanzitutto, viene ridotto, quindi reimpostato su 0, quindi impostato su 1, quindi stampato. Quindi, l'1 viene decrementato a 0. Successivamente, il programma viene eseguito come all'inizio fino a quando non tenta di farlo 0%0. Ciò lo fa gettare un errore silenzioso ed uscire.

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

Mi piace molto il trucco dell'errore silenzioso, ma un modo più semplice sarebbe quello di sostituirlo (con in /modo che l'IP passi per la prima volta, ma si rifletta in@ seconda.

Soluzione collaborativa (10):

non formattato:

?{?!1\@'%<

formattato:

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

Questo programma inizia come tutti gli altri programmi, ottenendo l'input e modificandolo.

Se l'ingresso è 0, l'IP gira a sinistra quando colpisce <. Viene deviato in 1!@, che stampa 1 ed esce.

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

Se l'ingresso è positivo, l'IP gira a destra quando colpisce <. Esce dall'angolo e percorre il bordo superiore destro colpendo @ senza stampare.

  . . ?
 . . . @
. . < . .
 . . . .
  . . .
— Blu
fonte
6
Penso che dovresti formattare la tua risposta in modo diverso. Avere quattro risposte in un singolo blocco di codice fa sembrare che il conteggio dei byte sia errato.
— mbomb007,
17

Brak-flak 102, 98, 96 byte

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

Eww. Schifoso. Potrei pubblicare una spiegazione, ma la capisco a malapena da sola. Questa lingua mi fa male al cervello.

Provalo online!

Grazie all'utente github @Wheatwizard per aver un esempio di modulo. Probabilmente non avrei potuto capirlo da solo!

Inoltre, la risposta più breve è qui .

Spiegazione forse errata:

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

Il resto è piuttosto semplice.

{              }            #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
— DJMcMayhem
fonte
The rest is pretty straightforward.Sì, sembra così.
— Erik the Outgolfer,
24 byte se si conteggia ogni istruzione brainflak come byte.
— noɥʇʎԀʎzɐɹƆ
12

Javascript (ES6) 17 12 11 byte

a=>b=>a%b<1
  • MODIFICARE: rimossi 5 byte perché è previsto 'a> 0'.
  • EDIT2: rimosso 1 byte grazie a Downgoat .
— ETHproductions
fonte
Usa il curry per salvare un byte: a => b =>
— Scarica il
Quindi, come posso eseguire questo? Quando provo d=a=>b=>a%b<1seguito dalla d(32,2)console JS ... ottengo semplicemente la rispostafunction b=>a%b<1
— WallyWest
@WallyWest utilizza curry, quindi dovresti digitare d(32)(2). Perché d(32)dà function b=>a%b<1, allora devi chiamare quella funzione con il tuo bvalore
— Cyoce
9

Vim, 11 sequenze di tasti

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

Non male per una lingua che gestisce solo le stringhe. : D

— DJMcMayhem
fonte
Cosa fa <C-Left>? Non posso provarlo perché cambia windows su mac> _>
— Downgoat
1
@Downgoat stai usando ctrl o comando? In entrambi i casi, equivale a "b", tranne per il fatto che funziona anche in modalità inserimento.
— DJMcMayhem
Per essere pedanti, è l'equivalente Bpiuttosto che b(e Ctrl+ Rightè l'equivalente di W) - la differenza è con caratteri non di parole, ma in questo caso sta facendo esattamente la stessa cosa :) vimdoc.sourceforge.net/htmldoc/motion. html # <C-Sinistra >
— Christian Rondeau,
9

Mathematica - 17 13 3 byte

∣

Grazie a @MartinEnder per aver salvato un sacco di byte!

— Yytsi
fonte
Che personaggio è quello?
— Cyoce,
@Cyoce Non conosco il suo codice Unicode (al telefono al momento), ma è un operatore corto per Divisible[].
— Yytsi,
@Cyoce Penso che sia il simbolo della pipa, noto anche come maiusc + barra rovesciata.
— Pavel,
@Pavel se fosse il simbolo della pipe, non sarebbe di tre byte.
— Cyoce,
@Cyoce è il personaggio U + 2223: fileformat.info/info/unicode/char/2223/index.htm
— numbermaniac
8

Retina, 12 byte

^(1+)\1* \1$

Accetta un input separato da spazio in unario, ad esempio 111111111111 1111per verificare se 12 se divisibile per 4 . stampe 1 (vero) o 0 (falso).

Provalo online!

FryAmTheEggman ha salvato due byte. Oops, riscrivi la mia risposta per prendere gli argomenti nel giusto ordine. (Poi Fry mi ha battuto nei commenti. Sono lento a regex!)

— Lynn
fonte
Per correggere l'ordine, se diventa necessario, penso ^(1+)\1* \1$che funzionerà.
— FryAmTheEggman,
Immagino che con le nuove specifiche, l'ordine di input opposto sia di nuovo a posto.
— Martin Ender,
8

Lotto, 20 byte

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

Risultati 1in caso di successo, 0in caso di fallimento.

— Neil
fonte
8

C #, 27 13 12 byte

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

Grazie a TuukkaX per la segnalazione di lambda anonime sono accettabili. Grazie a David Conrad per avermi indicato il curry che non sapevo nemmeno fosse una cosa.

Breve e dolce, poiché abbiamo a che fare solo con numeri interi che possiamo usare <1piuttosto che ==0salvare un intero byte.

— JustinM: ripristina Monica
fonte
Non sono sicuro, ma penso che si può semplicemente utilizzare un lambda: (a,b)=>a%b<1;. +1.
— Yytsi,
@TuukkaX, grazie non ne ero sicuro, sembra così economico.
— JustinM - Ripristina Monica il
La versione JS di questo usava il curry per ridurlo di un byte, e questo dovrebbe funzionare anche per C #: a=>b=>a%b<1;(nota: allora devi chiamarlo come f(a)(b)piuttosto che f(a,b))
— David Conrad,
1
@DavidConrad oo che è pulito, grazie.
— JustinM - Ripristina Monica il
7

Brainfuck, 53 byte

Accetta input come byte, l'output è un valore byte di 0x00o 0x01. È l' algoritmo DivMod seguito dalla negazione booleana .

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

Provalo online - Ha un sacco di extra+verso la fine in modo da poter vedere l'output in ASCII.

— mbomb007
fonte
Potresti rimuovere la parte "div" della cosa per salvare i byte?
— Leaky Nun,
1
@LeakyNun Questo è l'algoritmo più breve noto che fornisce il modulo. La rimozione di una parte di esso in realtà lo rende più lungo, perché sono necessarie più celle temporanee. Non puoi trovare un modulo senza dividere.
— mbomb007,
Vedo, grazie.
— Leaky Nun,
@LeakyNun Guarda quanto è lungo l' algoritmo Division .
— mbomb007,
Probabilmente ce ne sono di più brevi, ma in tal caso nessuno li ha trovati o pubblicati.
— mbomb007,
7

Brain-Flak , 88 86 byte

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

Questa è una versione più densa dell'algoritmo originale di test di divisibilità Brain-Flak scritto dal Dott. Green Eggs e Iron Man DJMcMayhem e me stesso.

Ecco una breve spiegazione (ish) di come funziona:

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

Provalo online!

— Mago del grano
fonte
Link all'interprete online?
— Leaky Nun,
Bel lavoro! Benvenuto anche nel sito! Spero che ti diverta qui. (Certamente)
— DJMcMayhem
Bella prima risposta, benvenuto in PPCG!
— Leaky Nun,
6

C, 60 byte

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}
— ronronner
fonte
1
Perché -1? Spiegami
— Ronronner,
3
È possibile che nessuno abbia effettuato il downgrade. Questa è una risposta breve, quindi è stata contrassegnata automaticamente come di bassa qualità e quindi modificata. Per qualche ragione, questo lancia un downvote automatico . Mi dispiace per quello. +1da me. Inoltre, consentiamo le funzioni, in modo che tu possa accorciarlo facilmente int f(a,b){return !(a%b);}o addirittura accorciarlo.
— DJMcMayhem
3
No, il mio punto è che non deve essere un programma completo. È possibile invece inviare solo una funzione. int f(a,b){return!(a%b);}è di 25 byte e se si utilizza il compilatore corretto, è possibile farlo anche f(a,b){return!(a%b);}per 21 byte.
— DJMcMayhem
3
Presentazione della funzione ancora più breve: #define f(a,b)!(a%b)( collegamento ideone )
— Mego
2
Devi definire una funzione o un programma, non solo uno snippet.
— Leaky Nun,
5

R, 22 20 byte

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

Come al solito, legge due numeri dall'input che termina con una riga vuota.

Aggiornamento: grazie a Jarko Dubbeldam per aver rasato 2 byte (nonostante il fatto che la sua modifica sia stata respinta, è stato molto utile!).

— Andreï Kostyrka
fonte
5

Java 8, 11 byte

a->b->a%b<1

Che diamine, ci sono versioni JS e C # di questo, perché non anche una versione Java?

Uso:

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);
    }
}
— David Conrad
fonte
a->b->a%b<1Questo genera un errore di sintassi, vero?
— Dorukayhan vuole Monica indietro il
2
No, è valido Java 8.
— David Conrad,
A volte anche Java sembra Perl ...
— Mega Man,
Sì, aggiungerei che questo è solo Java 8;).
— Magic Octopus Urn
quindi con Java 8 dobbiamo contare solo i byte di espressione lambda e non l'intera classe e funzione boilerplate, cool!
— Sikorski,
4

Python, 16 byte

lambda D,d:D%d<1
— Dennis
fonte
1
Nota che questo non funzionerebbe se fossero ammessi numeri interi negativi. Fortunatamente, gli input sono strettamente positivi.
— TLW,
L'ho fatto lambda a,b:1.*a/b==a/b, ma sono rimasto piuttosto colpito. Questo è un codice così complesso ...
— Erik the Outgolfer,
4

GolfScript, 3 byte

~%!

Spiegazione:

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

Provalo online!

— Loovjo
fonte
4

CJam, 6 4 byte

Salvato 2 byte grazie a Dennis

q~%!

Provalo online

q    e# Take in the input
 ~   e# Dump the individual values to the stack
  %  e# Modulus
   ! e# Boolean NOT
— Gatto di affari
fonte
3

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
— Jeremy
fonte
3

MarioLANG, 121 109 107 byte

Risparmiato 14 byte grazie a Martin Ender

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

Provalo online!

Spiegazione

L'algoritmo è semplicemente quello di mantenere sottraendo dda nper vedere se si può fare un numero intero di volte e non hanno alcun resto.

;
)
;

>
=
 
 

Innanzitutto, l'input viene raccolto. nè nella prima cella, dnella seconda.

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

Questo è essenzialmente il ciclo principale. Riduce la prima e la seconda cella e aumenta la terza.

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

Questo è l'output finale. Se dopo l'incremento / decremento, la prima cella è 0, allora abbiamo eliminato n. Se dopo questo, la seconda cella ( d) è 0, quindi è dandata in nmodo uniforme. Incrementiamo e stampiamo ( 1). Altrimenti, torna alla prima cella (che è 0) e stampala.

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

Questo ciclo si verifica se la seconda cella si trova 0dopo l'incremento e il decremento. Copia la terza cella nella seconda cella. La parte in basso è di bypassare il loop se la cella non lo è 0.

— Gatto di affari
fonte
3

Tcl, 34 byte

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

Il mio primo / * riuscito * / tentativo in codegolf! Questo codice deve essere eseguito nella shell Tcl, altrimenti non funzionerà.

Un byte grazie a @Lynn.

Quattro byte grazie a @Lynn e @LeakyNun (ora capisco cosa intendeva dire)!

Puoi omettere ?1:0?
— Leaky Nun,
@LeakyNun è un'operazione ternaria. intendi solo tornare sth quando è concepibile?
Cosa sarebbe $a%$b==0tornato?
— Leaky Nun,
1
Voglio dire, la tua terza linea può essere exp $a%$b==0?
— Leaky Nun,
1
O exp $a%$b<1forse?
— Lynn,
3

PHP, 23 22 byte

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

stampa 1 per vero, stringa vuota (= niente) per falso

chiama da cli con ne dcome argomenti

10 byte per PHP antico: <?=$n%$d<1

— Titus
fonte
Se non ti dispiace utilizzando PHP4.1: <?=!($A%$B). I valori possono essere passati come parte della vostra $_SESSION, $_COOKIE, $_POST, $_GETo (se non mi sbaglio) sopra $_ENV.
— Ismael Miguel,
@Ismael Miguel: In realtà non lo so, ma sono stanco di postare per le versioni di PHP antiche e aggiungere for PHP<5.4 with register_globals=On. Ma lo aggiungerò come riferimento.
— Tito,
In realtà, non puoi dire " for PHP<5.4 with register_globals=On", poiché devi contare i byte del tuo php.inifile contenente register_globals=On. Tuttavia, PHP4.1 è un caso speciale. È l'ultima versione in cui si register_globals=Ontrova il valore predefinito e la maggior parte delle funzioni sono disponibili da PHP4.1 in poi. Questa versione consente anche l'uso di altre funzioni, come erege splitsenza avvisi.
— Ismael Miguel,
3

J, 3 byte

0=|

Uso:

2 (0=|) 10

Tornerà 1. Ed è equivalente allo pseudocodice10 MOD 2 EQ 0

Nota che questo è molto simile alla risposta APL , perché J è fortemente ispirato da APL

— emiflake
fonte
Bella prima risposta, benvenuto in PPCG!
— Leaky Nun,
@LeakyNun Grazie, ho sempre cercato, bello rispondere finalmente.
— emiflake,
3

PowerShell v2 +, 20 byte

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

Prende input come due argomenti della riga di comando $args, -joinli unisce in una stringa con %come separatore, i pipe a iex(abbreviazione Invoke-Expressione simile a eval). Il risultato è 0o diverso da zero, quindi prendiamo il valore booleano non !di quel risultato, il che significa che $TRUEo $FALSE(i numeri interi diversi da zero in PowerShell sono veritieri). Quel booleano è rimasto sulla pipeline e l'output è implicito.

Versioni alternative, anche 20 byte ciascuna

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

Stesso concetto, modi leggermente diversi di strutturare l'input. Grazie a @DarthTwon per averli forniti.

Esempi

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
— AdmBorkBork
fonte
In entrambi gli altri metodi ho provato a giocare a golf questa domanda, li ho anche portati a 20 byte: param($a,$b)!($a%$b)e!($args[0]%$args[1])
— ThePoShWolf il
@DarthTwon Effettivamente. Quando si ha a che fare con piccole quantità di operazioni, di solito ci sono al massimo uno o due byte di differenze nei diversi modi di prendere gli argomenti di input.
— AdmBorkBork,
I was hoping to come up with something shorter :P but yeah, there's always multiple ways to skin the cat, especially in PS.
— ThePoShWolf
3

Haskell, 13 11 bytes

((1>).).mod

This defines a new function (!) :: Integral n => n -> n -> Bool. Since mod n m returns only positive numbers if n and m are positive, we can save a byte by using 1> instead of 0==.

Usage:

ghci> let n!d=1>mod n d
ghci> 100 ! 2
True
ghci> 100 ! 3
False
— Zeta
fonte
You can go pointfree and save 2 bytes: ((1>).).mod.
— nimi
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.