Citando questa domanda su SO (Spoiler alert!):

Questa domanda è stata posta in un'intervista a Oracle.

Come divideresti un numero per 3 senza usare *, /, +, -,%, operatori?

Il numero può essere firmato o non firmato.

L'attività è risolvibile, ma controlla se riesci a scrivere il codice più breve.

Regole:

• Esegue la divisione intera richiesta ( /3)
• Non utilizzare gli operatori non-text-based *, /, +, -, o %(o loro equivalenti, come ad esempio __div__o add()). Questo vale anche per gli operatori di incremento e decremento, come i++o i--. L'uso degli operatori per la concatenazione e la formattazione delle stringhe è OK. L'uso di questi caratteri per operatori diversi, come un -operatore unario per numeri negativi, o *per rappresentare un puntatore in C è anch'esso OK.
• Il valore di input può essere arbitrariamente grande (qualunque cosa il tuo sistema sia in grado di gestire), sia positivo che negativo
• L'ingresso può essere su STDIN o ARGV o inserito in altro modo
• Crea il codice più corto possibile per fare quanto sopra

J, 45 44 10 caratteri

".,&'r3'":

Funziona con negativi:

".,&'r3'": 15
5
   ".,&'r3'": _9
_3
   ".,&'r3'": 3e99
1e99

": - formatta come testo

,&'r3'- Aggiungi r3alla fine

". - esegue la stringa, ad es 15r3

C, 167503724710

Ecco la mia soluzione al problema. Devo ammettere che è improbabile che vinca una competizione di golf in codice rigoroso, ma non usa alcun trucco per chiamare indirettamente la funzionalità di divisione integrata, è scritto in C portatile (come richiesto dalla domanda originale Stack Overflow), funziona perfettamente per i numeri negativi e il codice è eccezionalmente chiaro ed esplicito.

Il mio programma è l' output del seguente script:

#!/usr/bin/env python3
import sys

# 71
sys.stdout.write('''#include <stdint.h>
#include <stdio.h>
int32_t div_by_3(int32_t input){''')

# 39 * 2**32
for i in range(-2**31, 2**31):
    # 18 + 11 + 10 = 39
    sys.stdout.write('if(input==%11d)return%10d;' % (i, i / 3))

# 95
sys.stdout.write(r'''return 7;}int main(int c,char**v){int32_t n=atoi(a[1]);printf("%d / 3 = %d\n",n, div_by_3(n));}''')

Numero di caratteri: 71 + 39 * 2 ** 32 + 95 = 167503724710

benchmark

È stato chiesto quanto tempo ci vorrebbe e quanta memoria avrebbe usato, quindi ecco alcuni parametri di riferimento:

• Tempo di esecuzione dello script: l'esecuzione ./test.py | pv --buffer-size=1M --average-rate > /dev/nullper circa 30 secondi fornisce una velocità di circa 14,8 MB / s. Si può ragionevolmente supporre che la velocità di uscita sia approssimativamente costante, quindi il tempo di esecuzione fino al completamento dovrebbe essere circa 167503724710 B / (14,8 * 1048576 B / s) ≈ 10794 s.
• Tempo di compilazione - Il compilatore TCC afferma di compilare il codice C a 29,6 MB / s , il che comporta un tempo di compilazione di 167503724710 B / (29,6 * 1048576 B / s) ≈ 5397 s. (Naturalmente questo può essere eseguito in una pipeline con lo script.)
• Dimensione del codice compilato: ho provato a stimarlo usando ./test.py | tcc -c - -o /dev/stdout | pv --buffer-size=1M --average-rate > /dev/null, ma sembra tccche non produca nulla fino a quando non legge l'intero file sorgente.
• Utilizzo della memoria da eseguire: poiché l'algoritmo è lineare (e tcc non si ottimizza su più righe), l'overhead della memoria dovrebbe essere solo di pochi kilobyte (a parte il codice stesso, ovviamente).

Ruby 28

b=->n{n.to_s(3).chop.to_i 3}

Per dividere per 3 dobbiamo solo rimuovere lo zero finale nel numero di base 3: 120 -> 11110 -> 1111 -> 40

Funziona con negativi:

ice distantstar:~/virt/golf [349:1]% ruby ./div3.rb
666
222
ice distantstar:~/virt/golf [349]% ruby ./div3.rb
-15        
-5

Ruby, 60 45

In alternativa, senza usare la conversione di base:

d = -> n {x = n.abs; r = (0..1.0 / 0) .step (3) .take (x) .index x; n> 0? r: -r}

d=->n{(r=1.step(n.abs,3).to_a.size);n>0?r:-r}

Mathematica, 13 caratteri

Mean@{#,0,0}&

JavaScript, 56

alert(Array(-~prompt()).join().replace(/,,,/g,1).length)

Fa una stringa di lunghezza ndi ripetizione ,s e sostituisce ,,,con 1. Quindi, misura la lunghezza risultante della stringa. (Speriamo che sia unario -permesso!)

Python, 41 38

print"-"[x:]+`len(xrange(2,abs(x),3))`

xrange sembra essere in grado di gestire grandi numeri (penso che il limite sia lo stesso di un lungo in C) quasi istantaneamente.

>>> x = -72
-24

>>> x = 9223372036854775806
3074457345618258602

Haskell, 90 106

d n=snd.head.dropWhile((/=n).fst)$zip([0..]>>=ν)([0..]>>=replicate 3>>=ν);ν q=[negate q,q]

Crea un elenco di ricerca infinito (pigro) [(0,0),(0,0),(-1,0),(1,0),(-2,0),(2,0),(-3,-1),(3,1), ...], taglia tutti gli elementi che non corrispondono n( /=è la disuguaglianza in Haskell) e restituisce il primo che lo fa.

Questo diventa molto più semplice se non ci sono numeri negativi:

25 27

(([0..]>>=replicate 3)!!)

restituisce semplicemente l' nelemento th dell'elenco [0,0,0,1,1,1,2, ...].

C #, 232 byte

Il mio primo codice golf ... E poiché non esisteva C # e volevo provare un metodo diverso non provato qui, ho pensato di provarlo. Come alcuni altri qui, solo numeri non negativi.

class l:System.Collections.Generic.List<int>{}class p{static void Main(string[] g){int n=int.Parse(g[0]);l b,a=new l();b=new l();while(a.Count<n)a.Add(1);while(a.Count>2){a.RemoveRange(0,3);b.Add(1);}System.Console.Write(b.Count);}}

Ungolfed

class l : System.Collections.Generic.List<int>
{ }
class p
{
    static void Main(string[] g)
    {
        int n = int.Parse(g[0]);
        l b, a = new l();
        b = new l();
        while (a.Count < n) a.Add(1);
        while (a.Count > 2)
        {
            a.RemoveRange(0, 3);
            b.Add(1);
        }
        System.Console.Write(b.Count);
    }
}

Perl (26 22)

$_=3x pop;say s|333||g

Questa versione (ab) utilizza il motore regex di Perl. Legge un numero come ultimo argomento della riga di comando ( pop) e crea una stringa di 3s di questa lunghezza ( "3" x $number). L'operatore di sostituzione regex ( s///, qui scritto con delimitatori diversi a causa delle regole del puzzle e con una gbandiera lobal) sostituisce tre caratteri con la stringa vuota e restituisce il numero di sostituzioni, che è il numero di input intero diviso per tre. Potrebbe anche essere scritto senza 3, ma la versione sopra sembra più divertente.

$ perl -E '$_=3x pop;say s|333||g' 42
14

C, 160 caratteri

Soluzione di divisione lunga carattere per carattere usando le tabelle di ricerca, cioè senza stringa atoi () o printf () per convertire tra 10 stringhe di base e numeri interi.

L'output a volte includerà uno zero iniziale - parte del suo fascino.

main(int n,char**a){
char*s=a[1],*x=0;
if(*s==45)s=&s[1];
for(;*s;s=&s[1])n=&x[*s&15],x="036"[(int)x],*s=&x["000111222333"[n]&3],x="012012012012"[n]&3;
puts(a[1]);
}

Nota:

• abusa dell'accesso all'array per implementare l'aggiunta.
• viene compilato con clang 4.0, altri compilatori potrebbero non essere validi.

test:

./a.out -6            -2
./a.out -5            -1
./a.out -4            -1
./a.out -3            -1
./a.out -2            -0
./a.out -1            -0
./a.out 0             0
./a.out 1             0
./a.out 2             0
./a.out 3             1
./a.out 4             1
./a.out 5             1
./a.out 6             2
./a.out 42            14
./a.out 2011          0670

Python 42

int(' -'[x<0]+str(len(range(2,abs(x),3))))

Dal momento che ogni soluzione pubblicata qui che ho controllato tronca i decimali qui è la mia soluzione che lo fa.

Python 50 51

int(' -'[x<0]+str(len(range([2,0][x<0],abs(x),3))))

Dal momento che Python fa la divisione del pavimento, ecco la mia soluzione che lo implementa.

L'intero di input è nella variabile x.

Testato in Python 2.7 ma sospetto che funzioni anche in 3.

JavaScript, 55

alert(parseInt((~~prompt()).toString(3).slice(0,-1),3))

Se uno non può usare -1, allora ecco una versione che lo sostituisce con ~0(grazie Peter Taylor!).

alert(parseInt((~~prompt()).toString(3).slice(0,~0),3))

C 83 caratteri

Il numero da dividere viene passato attraverso stdin e lo restituisce come codice di uscita da main() (% ERRORLEVEL% in CMD). Questo codice abusa di alcune versioni di MinGW in quanto quando le ottimizzazioni non sono attive, considera l'ultimo valore di assegnazione come un'istruzione di ritorno. Probabilmente può essere ridotto un po '. Supporta tutti i numeri che possono adattarsi a unint

Se negazione unaria (-) non è consentita: (129)

I(unsigned a){a=a&1?I(a>>1)<<1:a|1;}main(a,b,c){scanf("%i",&b);a=b;a=a<0?a:I(~a);for(c=0;a<~1;a=I(I(I(a))))c=I(c);b=b<0?I(~c):c;}

Se negato unario È permesso: (123)

I(unsigned a){a=a&1?I(a>>1)<<1:a|1;}main(a,b,c){scanf("%i",&b);a=b;a=a<0?a:-a;for(c=0;a<~1;a=I(I(I(a))))c=I(c);b=b<0?-c:c;}

EDIT: ugoren mi ha fatto notare che - ~ è un incremento ...

83 Caratteri se negato unario è permesso: D

main(a,b,c){scanf("%i",&b);a=b;a=a<0?a:-a;for(c=0;a<~1;a=-~-~-~a)c=-~c;b=b<0?-c:c;}

C, 139 caratteri

t;A(a,b){return a?A((a&b)<<1,a^b):b;}main(int n,char**a){n=atoi(a[1]);for(n=A(n,n<0?2:1);n&~3;t=A(n>>2,t),n=A(n>>2,n&3));printf("%d\n",t);}

Esegui con il numero come argomento della riga di comando

• Gestisce numeri sia negativi che positivi

test:

 ./a.out -6            -2
 ./a.out -5            -1
 ./a.out -4            -1
 ./a.out -3            -1
 ./a.out -2            0
 ./a.out -1            0
 ./a.out 0             0
 ./a.out 1             0
 ./a.out 2             0
 ./a.out 3             1
 ./a.out 4             1
 ./a.out 5             1
 ./a.out 6             2
 ./a.out 42            14
 ./a.out 2011          670

modifiche:

• salvato 10 caratteri mischiando l'aggiunta (A) per rimuovere le variabili locali.

ZSH - 31 20/21

echo {2..x..3}|wc -w

Per numeri negativi:

echo {-2..x..3}|wc -w

Con numeri negativi (ZSH + bc) -62 61

Probabilmente non dovrei dare due programmi come risposta, quindi eccone uno che funziona per qualsiasi segno di numero:

echo 'obase=10;ibase=3;'`echo 'obase=3;x'|bc|sed 's/.$//'`|bc

Questo utilizza lo stesso trucco di conversione di base della risposta di Artem Ice .

C, 81 73 caratteri

Supporta solo numeri non negativi.

char*x,*i;
main(){
    for(scanf("%d",&x);x>2;x=&x[~2])i=&i[1];
    printf("%d",i);
}

L'idea è di usare l'aritmico puntatore. Il numero viene letto nel puntatore x, che non punta da nessuna parte. &x[~2]= &x[-3]= x-3viene utilizzato per sottrarre 3. Questo viene ripetuto fino a quando il numero è superiore a 2. iconta il numero di volte in cui viene effettuato ( &i[1]= i+1).

Giava 86 79

Supponiamo che il numero intero sia in y:

Converte in una stringa in base 3, rimuove l'ultimo carattere (spostamento a destra ">>" in base 3), quindi converte nuovamente in numero intero.

Funziona con numeri negativi.

Se il numero, y, è <3 o> -3, allora dà 0.

System.out.print(~2<y&y<3?0:Long.valueOf(Long.toString(y,3).split(".$")[0],3));

Prima pubblicazione su code golf. =) Quindi non posso ancora commentare.

Grazie Kevin Cruijssen per i suggerimenti.

Python2.6 ( 29 ) ( 71 ) ( 57 ) ( 52 ) (43)

z=len(range(2,abs(x),3))
print (z,-z)[x<0]

print len(range(2,input(),3))

Modifica - Ho appena capito che dobbiamo gestire anche numeri negativi. Risolverà più tardi

Modifica2 - Risolto

Modifica3 - Hai salvato 5 caratteri seguendo i consigli di Joel Cornett

Edit4 - Poiché l'input non deve necessariamente provenire da STDIN o ARGV, è stato salvato 9 caratteri non prendendo input da stdin

Javascript, 47 29

Utilizza evalper generare dinamicamente a /. Utilizza +solo per la concatenazione di stringhe, non per l'aggiunta.

alert(eval(prompt()+"\57"+3))

EDIT: usato al "\57"posto diString.fromCharCode(47)

Rubino ( 43 22 17)

Non solo golf, ma anche eleganza :)

p Rational gets,3

L'output sarà simile (41/1). Se deve essere un numero intero, allora dobbiamo aggiungere .to_ial risultato, e se passiamo to_ia to_fallora potremo ottenere l'output anche per i float.

TI-Basic, 8 byte

Vincitore? :)

int(mean({Ans,0,0

PS Arrotonda all'infinito per numeri negativi (vedi qui per il perché). Per arrotondare a zero invece, sostituire int(con iPart(per nessuna modifica di byte.

Casi test

-4:prgmDIVIDE
              -2
11:prgmDIVIDE
               3
109:prgmDIVIDE
              36

Python 2.x, 54 53 51

print' -'[x<0],len(range(*(2,-2,x,x,3,-3)[x<0::2]))

Dov'è _il dividendo ed è inserito come tale.

>>> x=-19
>>> print' -'[x<0],len(range(*(2,-2,x,x,3,-3)[x<0::2]))
- 6

Nota: non sono sicuro se è consentito l'uso dell'interprete interattivo, ma secondo l'OP: "L'ingresso può essere su STDIN o ARGV o inserito in altro modo"

Modifica: ora per Python 3 (funziona in 2.x, ma stampa una tupla). Funziona con negativi.

C ++, 191

Con main e include, il suo 246, senza main e include, è solo 178. Newline conta come 1 carattere. Considera tutti i numeri come non firmati. Non ricevo avvisi per il ritorno principale di un int senza segno, quindi è giusto.

La mia prima presentazione di codegolf in assoluto.

#include<iostream>
#define R return
typedef unsigned int U;U a(U x,U y){R y?a(x^y,(x|y^x^y)<<1):x;}U d(U i){if(i==3)R 1;U t=i&3,r=i>>=2;t=a(t,i&3);while(i>>=2)t=a(t,i&3),r=a(r,i);R r&&t?a(r,d(t)):0;}U main(){U i;std::cin>>i,std::cout<<d(i);R 0;}

usa i turni per dividere il numero per 4 ripetutamente e calcola la somma (che converge in 1/3)

pseudocodice:

// typedefs and #defines for brevity

function a(x, y):
    magically add x and y using recursion and bitwise things
    return x+y.

function d(x):
    if x = 3:
        return 1.
    variable total, remainder
    until x is zero:
        remainder = x mod 4
        x = x / 4
        total = total + x
    if total and remainder both zero:
        return 0.
    else:
        return a(total, d(remainder)).

A parte questo, potrei eliminare il metodo principale nominando d main e facendolo prendere un carattere ** e usando i valori di ritorno dei programmi come output. Restituirà il numero di argomenti della riga di comando diviso per tre, arrotondato per difetto. Questo porta la sua lunghezza al 191 pubblicizzato:

#define R return
typedef unsigned int U;U a(U x,U y){R y?a(x^y,(x|y^x^y)<<1):x;}U main(U i,char**q){if(i==3)R 1;U t=i&3,r=i>>=2;t=a(t,i&3);while(i>>=2)t=a(t,i&3),r=a(r,i);R r&&t?a(r,d(t)):0;}

Golfscript - 13 caratteri

~3base);3base

PowerShell 57 o 46

In 57 caratteri utilizza %come operatore foreach PowerShell, non modulo. Questa soluzione può accettare numeri interi positivi o negativi.

(-join(1..(Read-Host)|%{1})-replace111,0-replace1).Length

In 46 caratteri se *è consentito come operatore di ripetizione stringa, non moltiplicare. Questa opzione richiede numeri interi positivi come valori di input.

("1"*(Read-Host)-replace111,0-replace1).Length

R

Funzionano solo con numeri interi positivi:

max(sapply(split(1:x,1:3), length))
# Gives a warning that should be ignored

O:

min(table(rep(1:3, x)[1:x]))

O:

length((1:x)[seq(3,x,3)])

O:

sum(rep(1,x)[seq(3,x,3)])

[[EDIT]] E brutto:

trunc(sum(rep(0.3333333333, x)))

[[EDIT2]] Più probabilmente il migliore - ispirato al codice matlab sopra di Elliot G:

length(seq(1,x,3))

SmileBASIC, 58 51 36 byte (nessuna funzione matematica!)

INPUT N
BGANIM.,4,-3,N
WAIT?BGROT(0)

Spiegazione:

INPUT N           'get input
BGANIM 0,"R",-3,N 'smoothly rotate background layer 0 by N degrees over 3 frames
WAIT              'wait 1 frame
PRINT BGROT(0)    'display angle of layer 0

Il programma sposta uniformemente il livello di sfondo su 3 fotogrammi, quindi ottiene l'angolo dopo 1 fotogramma, quando ha percorso 1/3 della sua distanza totale.

Versione Float Division, 38 byte:

INPUT N
BGANIM.,7,-3,N
WAIT?BGVAR(0,7)

Spiegazione:

INPUT N           'input
BGANIM 0,"V",-3,N 'smoothly change layer 0's internal variable to N over 3 frames
WAIT              'wait 1 frame
PRINT BGVAR(0,7)  'display layer 0's internal variable

Haskell 41 39 caratteri

Funziona con l'intero set di numeri interi positivi e negativi

f n=sum[sum$1:[-2|n<0]|i<-[3,6..abs n]]

Innanzitutto crea un elenco di 1 o (-1) (a seconda del segno dell'input) per ogni terzo intero da 0 fino all'input n. abs(n)per i numeri negativi inclusi.

per esempio n=8 -> [0,3,6]

Restituisce quindi la somma di questo elenco.

Clojure, 87; lavora con negativi; basato su lazyseqs

(defn d[n](def r(nth(apply interleave(repeat 3(range)))(Math/abs n)))(if(> n 0)r(- r)))

Ungolfed:

(defn d [n]
  (let [r (nth (->> (range) (repeat 3) (apply interleave))
               (Math/abs n))]
        (if (pos? n)
          r
          (- r))))

Sage Notebook (21)

ZZ(n.digits(3)[1:],3)