Veuillez excuser le titre punny.

Cette question est inspirée d' une propriété curieuse de 82000 . L'auteur y indique que le nombre 82000 est binaire en base 2, 3, 4 et 5. Le post pose alors la question "y a-t-il un nombre binaire en base 2, 3, 4, 5 et 6? "? (Pour les curieux, j'ai vérifié des valeurs allant jusqu'à 10 ^ 1 000 000 et jusqu'à présent, la réponse est non.)

Cela m'a fait penser: étant donné un nombre, dans quelles bases est- il binaire?

Notre nombre curieux, 82000, est en fait binaire en six bases:

Base 2 = 10100000001010000
Base 3 = 11011111001
Base 4 = 110001100
Base 5 = 10111000
Base 81999 = 11
Base 82000 = 10

Tous les nombres n'auront pas de bases binaires séquentielles. Considérez le nombre 83521. Il est binaire dans les bases 2, 17, 289, 83520 et 83521.

Votre défi consiste à déterminer et à afficher dans quelles bases un nombre est binaire.

Règles

• Un nombre est considéré comme "binaire" dans une base donnée si sa représentation dans cette base se compose uniquement de zéros et de uns. 110110est une valeur binaire, alors qu'elle 12345ne l'est pas, ne l' A380Fest certainement pas.
• Votre numéro sera fourni sur une entrée standard. Ce sera une valeur entière comprise entre 2 et 2 ^ 32-1 inclus et sera fournie au format base 10.
• Dans l'ordre croissant, affichez chaque base supérieure à une dans laquelle le nombre est binaire. Chaque base doit être sur sa propre ligne. Si vous incluez la valeur binaire dans cette base (voir le score bonus ci-dessous), séparez la base et la valeur binaire avec un espace. Seule la sortie vers la sortie standard sera jugée, l'erreur standard et les autres sources seront ignorées.

Notation

Votre score est la taille de votre programme en octets. Plus le score est bas, mieux c'est.

Bonus :
si votre programme génère également les valeurs binaires dans les bases trouvées, multipliez votre score par 0,75
.

Exemples

Contribution:

82000

Sortie (reçoit un bonus):

2 10100000001010000
3 11011111001
4 110001100
5 10111000
81999 11
82000 10

Contribution:

1234321

Sortie (pas de bonus):

2
1111
1234320
1234321

Pyth, 14 13

jbf!-jQTU2tSQ

Merci à Jakube d'avoir souligné la nouvelle Sfonction.

Essayez-le ici.

La version en ligne est trop lente à faire 1234321. Cela convertit simplement l'entrée de chaque base de 2 en elle-même et supprime les résultats qui contiennent des valeurs autres que 0 et 1.

Explication:

                           : Q=eval(input) (implicit)
jb                         : join on newlines the list...
  f!                       : filter away nonempty values (impliticly named T)
    -jQTU2                 : sewtise difference of number converted to base and range(2)
     jQT                   : convert Q to base T
        U2                 : range(2)
          tSQ              : over the range [2 Q+1)

De plus, c'est une version bonus ( pas bien jouée maintenant bien jouée, encore grâce à Jakube) (20 * .75 = 15):

VQI!-JjQK+2NU2pdKjkJ

Essayez-le ici

Julia, 72 70 octets

C'est en fait plus long avec le bonus, donc pas de bonus ici.

n=int(readline());for j=2:n all(i->i∈0:1,digits(n,j))&&println(j)end

Cela lit une ligne de STDIN, la convertit en un entier et imprime le résultat. En dépit d'être une méthode de force brute, l'entrée 1234321 m'a pris moins d'une seconde.

Non golfé + explication:

# Read n from STDIN and convert to integer
n = int(readline())

# For every potential base from 2 to n
for j = 2:n
    # If all digits of n in base j are 0 or 1
    if all(i -> i ∈ 0:1, digits(n, j))
        # Print the base on its own line
        println(j)
    end
end

Exemples:

julia> n=int(readline());for j=2:n all(i->i∈0:1,digits(n,j))&&println(j)end
1234321
2
1111
1234320
1234321

julia> n=int(readline());for j=2:n all(i->i∈0:1,digits(n,j))&&println(j)end
82000
2
3
4
5
81999
82000

REMARQUE : Si l'entrée peut être considérée comme un argument de fonction plutôt que depuis STDIN (en attente de confirmation de l'OP), la solution est de 55 octets.

CJam, 20 octets (ou 27 octets * 0,75 = 20,25)

Voici la version sans bonus, 20 octets:

ri:X,2f+{X\b2,-!},N*

Essayez ceci ici.

Juste pour le plaisir, voici la version bonus, 27 octets:

ri:X{X\)b2,-!},1>{)SX2$bN}/

Essayez-le en ligne ici

Mathematica, 59 octets

Print/@Select[1+Range[n=Input[]],Max@IntegerDigits[n,#]<2&]

Ugh ... IntegerDigitsD:

Il n'y a pas grand-chose à expliquer sur le code ... 12 octets sont gaspillés par la nécessité d'utiliser STDIN et STDOUT.

Je ne pense pas pouvoir réclamer le bonus. Le meilleur que j'ai est de 84 octets (ce qui donne un score supérieur à 60):

Print@@@Select[{b=#+1," ",##&@@n~IntegerDigits~b}&/@Range[n=Input[]],Max@##3<2&@@#&]

Python 2, 88 86 80

Assez simple, pas de bonus. Python est agréable et indulgent avec les variables globales.

N=input();g=lambda n:n<1or(n%b<2)*g(n/b)
for b in range(2,N+1):
 if g(N):print b

Le meilleur que j'ai réussi à obtenir pour le bonus est de 118 * 0,75 = 87,75 :

N=input();g=lambda n:0**n*" "or" "*(n%b<2)and(g(n/b)+`n%b`)*(g(n/b)>'')
for b in range(2,N+1):
 if g(N):print`b`+g(N)

Python 2, 90 * 0,75 = 67,5

n=input();b=1
while b<n:
 b+=1;s="";c=k=n
 while k:s=`k%b`+s;c*=k%b<2;k/=b
 if c:print b,s

Approche itérative assez simple.

Sans le bonus, cela fait 73 octets:

n=input();b=1
while b<n:
 b+=1;c=k=n
 while k:c*=k%b<2;k/=b
 if c:print b

SQL (PostgreSQL), 247,5 255 230,25 (307 * 0,75)

Étant donné que SQL est connu pour être merveilleux dans ce genre de défis, j'ai pensé que je ferais mieux d'en mettre un ensemble :) Le bonus valait vraiment la peine pour celui-ci.
Il doit être conforme aux spécifications, mais je n'ai aucun moyen facile de tester la COPIE I ​​DE STDIN .
Modifier l' ordre fixe. Modification de la façon dont la colonne R est gérée pour utiliser un tableau.

CREATE TABLE IF NOT EXISTS I(I INT);TRUNCATE TABLE I;COPY I FROM STDIN;WITH RECURSIVE R AS(SELECT n,I/n I,ARRAY[I%n] R FROM generate_series(2,(SELECT I FROM I))g(n),(SELECT I FROM I)I(I)UNION ALL SELECT n,I/n,I%n||R FROM R WHERE I>0)SELECT n||' '||array_to_string(R,'')FROM R WHERE 2>ALL(R)and i=0ORDER BY n

Comme test, je viens d'utiliser des inserts droits dans la Itable. Le test a été étendu et commenté.

-- Create the table to accept the input from the copy command
CREATE TABLE IF NOT EXISTS I(I INT);
-- Make sure that it is empty
TRUNCATE TABLE I;
-- Popoulate it with a value from STDIN
--COPY I FROM STDIN;
INSERT INTO I VALUES(82000); -- Testing
--Using a recursive CTE query
WITH RECURSIVE R AS (
    -- Recursive anchor
    SELECT n,                -- base for the row
       I/n I,                -- integer division
       ARRAY[I%n] R   -- put mod value in an array
    FROM generate_series(2,(SELECT I FROM I))g(n), -- series for the bases
         (SELECT I FROM I)I(I) -- Cross joined with I,  saves a few characters
    UNION ALL 
    -- for each row from r recursively repeat the division and mod until i is 0
    SELECT n,
        I/n,
        I%n||R -- Append mod to beginning of the array
    FROM R WHERE I>0
    )
-- return from r where i=0 and r has 1's and 0's only
SELECT n||' '||array_to_string(R,'')
FROM R 
WHERE 2 > ALL(R)and i=0
ORDER BY n -- Ensure correct order

2 10100000001010000
3 11011111001
4 110001100
5 10111000
81999 11
82000 10

Haskell 109 * 0,75 = 81,75 octets

0#x=[]
n#x=n`mod`x:div n x#x 
f n=[show x++' ':(n#x>>=show)|x<-[2..n+1],all(<2)$n#x]
p=interact$unlines.f.read

Exemple d'utilisation (remarque: les valeurs binaires sont d'abord lsb):

p 82000

2 00001010000000101
3 10011111011
4 001100011
5 00011101
81999 11
82000 01

Sans restrictions d'entrée / sortie, c'est-à-dire entrée via l'argument de fonction, sortie au format natif via REPL):

Haskell, 67 * 0,75 = 50,25 octets

0#x=[]
n#x=n`mod`x:div n x#x
f n=[(x,n#x)|x<-[2..n+1],all(<2)$n#x]

Renvoie une liste de paires (base, valeur). Les valeurs sont d'abord lsb, par ex. (Sauts de ligne / espaces ajoutés pour un meilleur affichage):

 f 82000
 [ (2,[0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1]),
   (3,[1,0,0,1,1,1,1,1,0,1,1]),
   (4,[0,0,1,1,0,0,0,1,1]),
   (5,[0,0,0,1,1,1,0,1]),
   (81999,[1,1]),
   (82000,[0,1]) ] 

R, 111

Probablement beaucoup de place pour améliorer cela en ce moment

i=scan();b=2:i;R=i%%b;I=rep(i,i-1);while(any(I<-I%/%b))R=cbind(I%%b,R);for(x in b)if(all(R[x-1,]<2))cat(x,'\n')

Fonctionne avec des avertissements

> i=scan();b=2:i;R=i%%b;I=rep(i,i-1);while(any(I<-I%/%b))R=cbind(I%%b,R);for(x in b)if(all(R[x-1,]<2))cat(x,'\n')
1: 82000
2: 
Read 1 item
There were 17 warnings (use warnings() to see them)
2 
3 
4 
5 
81999 
82000
>

Java, 181 155,25 (207 * .75) 151,5 (202 * .75) octets

class I{public static void main(String[]a){a:for(long b=new java.util.Scanner(System.in).nextLong(),c,d=1;d++<b;){String e="";for(c=b;c>0;e=c%d+e,c/=d)if(c%d>1)continue a;System.out.println(d+" "+e);}}}

Développé avec explication:

class I {
    public static void main(String[]a){
        a:for(long b=new java.util.Scanner(System.in).nextLong(),c,d=1; //b = input(), d = base
              d++<b;) {                                           //For all bases in range(2,b+1)
            String e="";
            for(c = b;c > 0; e = c % d + e,c /= d)                //Test all digits of base-d of b
                           //e = c % d + e                        //Append digits to string
                if (c % d > 1)                                    //Reject base if the digit is greater than 1
                    continue a;
            System.out.println(d+" "+e);                          //Print base and digits.
        }
    }
}

Original (sans bonus):

class I{public static void main(String[]a){long b=new java.util.Scanner(System.in).nextLong(),c,d=1;a:for(;d++<b;){c=b;while(c>0){if(c%d>1)continue a;c/=d;}System.out.println(d);}}}

3,75 octets grâce à Ypnypn :)

R, 94 83 79

n=scan();cat((2:n)[!sapply(2:n,function(x){while(n&n%%x<2)n=n%/%x;n})],sep="\n")

Usage:

> n=scan();cat((2:n)[!sapply(2:n,function(x){while(n&n%%x<2)n=n%/%x;n})],sep="\n")
1: 82000
2: 
Read 1 item
2
3
4
5
81999
82000
> n=scan();cat((2:n)[!sapply(2:n,function(x){while(n&n%%x<2)n=n%/%x;n})],sep="\n")
1: 1234321
2: 
Read 1 item
2
1111
1234320
1234321

Le noyau de la fonction est !sapply(2:n,function(x){while(n&n%%x<2)n=n%/%x;n})qui, pour chaque base x de 2 à n, conserve le quotient n / x tant que le reste est soit 0 et 1. Il produit ensuite le résultat (qui est 0 si tous les restes étaient soit 1 ou 0) et le nie (0 nie à VRAI, tout le reste nie à FAUX). Grâce à la portée de la fonction, il n'est pas nécessaire de créer une variable fictive pour n. Le vecteur de booléens résultant est ensuite utilisé pour indexer 2:net ne sort donc que les bases pour lesquelles il a fonctionné.

TI-Basic, 45 octets

Input N
For(B,2,N
If prod(seq(BfPart(iPart(N/B^X)/B),X,0,log(N)/log(B))<2
Disp B
End

Explication

• Entrée N
• Pour chaque B de 2 à N
  • Si N est juste 0 et 1 en base B
    • Affichage B
• Boucle de fin

La partie compliquée

La deuxième ligne fonctionne comme suit:

• Pour chaque X de 0 à log _B N
• B × fPart (iPart (N / B ^X ) / B) est le Nième chiffre de la base B, en comptant à rebours
• Considérez cela comme une liste
• Pour chaque élément, si le chiffre est inférieur à 2, donnez 1 (vrai), sinon 0 (faux)
• Prenez le produit: 1 si tous les éléments sont 1

Remarque

Le programme s'exécute beaucoup plus rapidement si une parenthèse fermante )est placée à la fin de la deuxième ligne. Voir ici pour en savoir plus.

TI-BASIC, 31 29

For(B,2,Ans
If 2>round(Bmax(fPart(Ans/B^randIntNoRep(1,32
Disp B
End

C'est probablement optimal pour TI-BASIC.

Explication:

randIntNoRep(1,32)renvoie une permutation aléatoire des nombres de 1 à 32 (Tout ce dont nous avons besoin est ces nombres dans un certain ordre; TI-BASIC n'a rien de semblable à la commande iota d'APL). 32 éléments suffisent car la plus petite base possible est 2 et le plus grand nombre est 2 ^ 32-1. B^randIntNoRep(1,31)élève cette liste à la puissance Bth, ce qui entraîne la liste contenant tout B^1,B^2,...,B^32(dans un certain ordre).

Ensuite, l'entrée (dans la Ansvariable wer, qui est entrée dans le formulaire [number]:[program name]) est divisée par ce nombre. Si votre entrée est 42 et la base est 2, le résultat sera la liste 21,10.5,5.25,...,42/32,42/64,[lots of numbers less than 1/2], encore une fois dans un certain ordre.

Prendre la partie fractionnaire et multiplier le nombre par votre base donne le chiffre à cette position dans la représentation base-b. Si tous les chiffres sont inférieurs à 2, le plus grand chiffre sera inférieur à 2.

Comme l'a indiqué Ypnypn, une parenthèse fermante sur l' Forinstruction accélère cela en raison d'un bug de l'analyseur.

31-> 31: enregistrement d'un octet mais correction des erreurs d'arrondi qui ajoutaient à nouveau l'octet.

31-> 29: enregistré deux octets en utilisant RandIntNoRep()au lieu de cumSum(binomcdf()).

Gelée , 9 octets

³bṀỊµÐfḊY

Essayez-le en ligne!

Fait aux côtés de caird coinheringaahing dans le chat .

Comment ça marche

³bṀỊµÐfḊY Programme complet.

     Ðf Filtre la plage générée implicitement [1, entrée].
    µ Démarre une nouvelle chaîne monadique.
³b Convertissez l'entrée en base du nombre actuel, sous forme de liste.
  Ṁ Maximum.
   Ị Insignifiant. Vérifie si abs (Z) ≤ 1.
       Ḋ retirer la file d'attente; Supprime le premier élément de la liste (pour supprimer la base 1).
        Y Rejoignez par des nouvelles lignes.

Javascript, ES6, 118 * 0,75 = 88,5 110 * 0,75 = 82,5

f=x=>{res={};for(b=2;b<=x;++b)if(!+(res[b]=(c=x=>x%b<2?x?c(x/b|0)+""+x%b:"":"*")(x)))delete res[b];return res}

La version précédente:

f=x=>{res={};for(q=2;q<=x;++q)if(!+(res[q]=(c=(x,b)=>x%b<2?x?c(x/b|0,b)+""+x%b:"":"*")(x,q)))delete res[q];return res}

Vérifier:

f(82000)
Object { 2: "10100000001010000", 3: "11011111001", 4: "110001100", 5: "10111000", 81999: "11", 82000: "10" }

JavaScript ( ES6 ) 65

68 octets pour une fonction avec un paramètre et une sortie console.

f=n=>{s=n=>n%b>1||b<n&&s(n/b|0);for(b=1;b++<n;)s(n)||console.log(b)}

65 octets avec E / S via popup

n=prompt(s=n=>n%b>1||b<n&&s(n/b|0));for(b=1;b++<n;)s(n)||alert(b)

Réclamation du bonus: 88 * 0,75 => 66

n=prompt(s=n=>n%b>1?9:(b<=n?s(n/b|0):'')+n%b);for(b=1;b++<n;)s(n)<'9'&&alert(b+' '+s(n))

Mathematica, 76 * 0,75 = 57

n=Input[];G=#~IntegerDigits~b&;If[Max@G@n<2,Print[b," ",Row@G@n]]~Do~{b,2,n}

Initialement oublié les exigences d'entrée ... Heureusement, celles-ci n'ont pas ajouté trop de choses.

Rubis , 44 octets

->n{(2..n).select{|i|n.digits(i)-[0,1]==[]}}

Essayez-le en ligne!

Perl 5 , 63 octets

map{$t=$n;1while($f=$t%$_<2)&&($t=int$t/$_);say if$f}2..($n=<>)

Essayez-le en ligne!

Aucun bonus à ce sujet car il marque très légèrement mieux que ma version avec le bonus:

Perl 5 , 85 octets * 0,75 = 63,75

map{my$r;$t=$n;$r=$/.$r while($/=$t%$_)<2&&($t=int$t/$_);say"$_ 1$r"if$/<2}2..($n=<>)

Essayez-le en ligne!