Arbitrary Precision Integer Division
Java 8, 485 bytes
Could reduce by another 5 bytes naming the function d instead of divide or another 16 bytes if not counting class-definition.

public class G{int l(String a){return a.length();}String s(String n,String m){while(l(n)&gt;l(m))m=0+m;String a=&quot;&quot;;for(int c=1,i=l(n);i&gt;0;c=c/10){c=n.charAt(--i)+c-m.charAt(i)+9;a=c%10+a;}return e(a);}String e(String a){return a.replaceAll(&quot;^0+(?=[0-9])&quot;,&quot;&quot;);}String divide(String n,String m){String q=&quot;&quot;,p=q,y;for(int b=0,i=0;b&lt;=l(n);i--){y=n.substring(0,b);if(l(y)==l(p)&amp;&amp;p.compareTo(y)&lt;=0||l(y)&gt;l(p)){y=s(y,p);n=y+n.substring(b);q+=i;b=l(y)+1;i=10;p=m+0;}p=s(p,m);}return e(q)+&quot;,&quot;+n;}}

Can be used like this:
public static void main(String[] args) {
    G devision = new G();
    System.out.println(devision.divide(&quot;20397882081197443358640281739902897356800000000&quot;,
            &quot;265252859812191058636308480000000&quot;));
    System.out.println(devision.divide(&quot;31035053229546199656252032972759319953190362094566672920420940313&quot;,
            &quot;1234567891011121314151617181920&quot;));
    System.out.println(devision.divide(
            &quot;271841734957981007420619769446411009306983931324177095509044302452019682761900886307931759877838550251114468516268739270368160832305944024022562873534438165159941045492295721222833276717171713647977188671055774220331117951120982666270758190446133158400369433755555593913760141099290463039666313245735358982466993720002701605636609796997120000000000000000000000000000000000000000000000000&quot;,
            &quot;247&quot;));
}

yielding
76899763100160,0
25138393324103249083146424239449429,62459510197626865203087816633
1100573825740813795225181252819477770473619155158611722708681386445423816849801159141424129060075102231232666057768175183676764503262931271346408394876267875141461722640873365274628650676808557279259873162169126398101692109801549256156915750794061370041981513180387019893765753438422927286098434193260562682052606153857091520795991080960000000000000000000000000000000000000000000000000,0

Ungolfed:
public class ArbitraryPrecisionDivision {

    /**
     * Length of String
     */
    int l(String a) {
        return a.length();
    }

    /**
     * substract m of n; n &gt;= m
     */
    String s(String n, String m) {
        while (l(n) &gt; l(m))
            m = 0 + m;
        String a = &quot;&quot;;
        for (int c = 1, i = l(n); i &gt; 0; c = c / 10) {
            c = n.charAt(--i) + c - m.charAt(i) + 9;
            a = c % 10 + a;
        }
        return e(a);
    }

    /**
     * trim all leading 0s
     */
    String e(String a) {
        return a.replaceAll(&quot;^0+(?=[0-9])&quot;, &quot;&quot;);
    }

    /**
     * divide n by m returning n/m,n%m; m may not start with a 0!
     */
    String divide(String n, String m) {
        // q stores the quotient, p stores m*i, y are the b leading digits of n
        String q = &quot;&quot;, p = q, y;
        for (int b = 0, i = 0; b &lt;= l(n); i--) {
            y = n.substring(0, b);
            if (l(y) == l(p) &amp;&amp; p.compareTo(y) &lt;= 0 || l(y) &gt; l(p)) {
                y = s(y, p);
                n = y + n.substring(b);
                q += i;
                b = l(y) + 1;
                i = 10;
                p = m + 0;
            }
            p = s(p, m);
        }
        return e(q) + &quot;,&quot; + n;
    }

    public static void main(String[] args) {
        ArbitraryPrecisionDivision division = new ArbitraryPrecisionDivision();
        System.out.println(division.divide(&quot;20397882081197443358640281739902897356800000000&quot;,
                &quot;265252859812191058636308480000000&quot;));
        System.out.println(division.divide(&quot;31035053229546199656252032972759319953190362094566672920420940313&quot;,
                &quot;1234567891011121314151617181920&quot;));
        System.out.println(division.divide(
                &quot;271841734957981007420619769446411009306983931324177095509044302452019682761900886307931759877838550251114468516268739270368160832305944024022562873534438165159941045492295721222833276717171713647977188671055774220331117951120982666270758190446133158400369433755555593913760141099290463039666313245735358982466993720002701605636609796997120000000000000000000000000000000000000000000000000&quot;,
                &quot;247&quot;));
    }
}

I sacrificed a bit of speed by not precalculating an array with m times 1 through 9 and starting with b=0 instead of b=l(m), but saved lots of bytes doing so. If you are interested in arbitrary precision addition see a previous version.
I guess this will not be the shortest solution, but maybe it gives a good start.