Compter de 1 à un entier… en binaire

13

Intro:

Je me souviens, quand j'étais enfant, je recevais une calculatrice et je continuais d'appuyer sur le +bouton, et je voyais à quel point je pouvais compter. Maintenant, j'aime programmer et je développe pour iOS.

Le comptage est une compétence fondamentale pour les humains et les ordinateurs. Sans cela, le reste des mathématiques ne peut pas être fait. Cela se fait simplement en commençant par 1et en l'ajoutant de manière répétitive 1.

Le défi:

Ce n'est qu'un simple défi. Ce que j'aimerais que votre programme fasse, c'est d'imprimer à partir 1de ce Integerqu'il contient. Cependant, je vais y apporter une touche, car le décimal est un peu ennuyeux:

Le comptage ne peut pas être en base 10, il doit se montrer comptant en binaire.

Donc, pour compter jusqu'à 5, en utilisant des entiers 32 bits, cela ressemblerait à ceci:

0000 0000 0000 0000 0000 0000 0000 0001 ..... 1
0000 0000 0000 0000 0000 0000 0000 0010 ..... 2
0000 0000 0000 0000 0000 0000 0000 0011 ..... 3
0000 0000 0000 0000 0000 0000 0000 0100 ..... 4
0000 0000 0000 0000 0000 0000 0000 0101 ..... 5

C'est un ordinateur. Ils connaissent le mieux le binaire. Votre entrée peut être un entier 32 bits ou 64 bits. Cela dépend vraiment de vous. Cependant, si vous utilisez des entiers 32 bits, votre sortie doit être des entiers 32 bits en binaire et si vous utilisez des entiers 64 bits, votre sortie doit être des entiers 64 bits en binaire .

Exemple d'entrée:

un entier 32 bits, 5

Exemple de sortie:

0000 0000 0000 0000 0000 0000 0000 0001
0000 0000 0000 0000 0000 0000 0000 0010
0000 0000 0000 0000 0000 0000 0000 0011
0000 0000 0000 0000 0000 0000 0000 0100
0000 0000 0000 0000 0000 0000 0000 0101

Notation:

Votre score est égal au nombre d'octets de votre code. Comme il s'agit de Code Golf, le score le plus bas l'emporte.

Points bonus:

Si vous montrez, dans la sortie, le nombre auquel il correspond en tant que nombre de base 10 (par exemple, 0000 0000 0000 0000 0000 0000 0000 0001en binaire est égal à la base 10 1), multipliez votre score par 0.8.

Si vous regroupez 4 chiffres de sortie comme je l'ai fait, multipliez votre score par 0.8(à nouveau). Ce n'est pas obligatoire.

Ne pas arrondir et ne pas arrondir. Votre score est un nombre à virgule flottante.

Bonne chance!

code-golf 
— DDPWNAGE
source
Devez-vous mettre les chiffres en morceaux de quatre séparés par des espaces?
— xnor
@xnor Non. Je l'ai fait pour la lisibilité, mais je vais également inclure une opportunité de bonus pour cela.
— DDPWNAGE
Et si j'utilise un type de données de taille illimitée (Python 3 intpar exemple)?
— isaacg
@isaacg Spécifiez si votre programme utilise des entiers 32 ou 64 bits. Vous n'êtes pas obligé de prendre en compte les nombres entiers hors limites; vous n'avez qu'à sortir ce que vous avez entré. En d'autres termes, le choix vous appartient.
— DDPWNAGE
4
Et si notre jauge utilise quelque chose de différent, comme des entiers 30 bits (Haskell) ou des entiers de précision arbitraire (J)?
— FUZxxl

Réponses:

14

APL, 10 caractères

Un autre dans APL. Suppose ⎕IO←1(par défaut). Pas de points bonus. Lit le numéro du périphérique d'entrée. Si votre APL utilise des entiers 64 bits au lieu de 32 bits, remplacez 64 par 32 si nécessaire.

Notez que APL convertit de manière transparente en nombres à virgule flottante lorsque la plage d'un entier est dépassée. Il est donc difficile de dire exactement avec quelle taille entière APL fonctionne.

⍉(32⍴2)⊤⍳⎕

explication

2          ⍝ the number 2
32⍴2       ⍝ a vector of 32 twos.
(32⍴2)⊤X   ⍝ X represented as base 2 to 32 digits precision
⍳X         ⍝ a vector of the integers from 1 to X
⎕          ⍝ a number queried from the terminal
(32⍴2)⊤⍳⎕  ⍝ the output we want, flipped by 90°
⍉(32⍴2)⊤⍳⎕ ⍝ the output we want in correct orientation (⍉ is transpose)
— FUZxxl
source
on dirait que je n'aurais pas dû essayer si dur pour obtenir les 4 groupements haha
— protiste
@protist N'essayez pas d'obtenir des points bonus trop difficiles à mettre en œuvre. Cela ne vaut presque jamais l'effort.
— FUZxxl
La question demandait spécifiquement un nombre d'octets plutôt qu'un caractère, donc le score devrait être de 20 octets.
— ankh-morpork
@ dohaqatar7 Il existe des encodages APL (comme la page de codes 907 ) qui intègrent l'ensemble du jeu de caractères APL dans un octet. Il existe des extensions APL qui ne peuvent pas être encodées avec les pages de codes APL traditionnelles, mais je n'en utilise aucune.
— FUZxxl
7

JavaScript ( ES6 ) 56,8 (71 * 0,8)

Version 32 bits, car JavaScript ne peut pas gérer la précision 64 bits (au plus 53 bits en utilisant des doubles à virgule flottante)

Sans regroupement

f=n=>{for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).slice(1),i)}

Avec groupement - score 60,16 (94 * 0,64)

f=n=>{for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).slice(1).match(/..../g).join` `,i)}

Testez dans n'importe quel navigateur (ES5)

function f(n)
{
  for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).substr(1).match(/..../g).join(' '),i)
}

// Test
console.log = function(x,y) { O.innerHTML += x+' '+y+'\n' }
Count to: <input id=I><button onclick="O.innerHTML='';f(+I.value)">-></button>
<pre id=O></pre>
Développer l'extrait

— edc65
source
6

Pyth, 18 * 0,8 * 0,8 = 11,52 octets

VSQjd+c.[64.BN\04N

Exemple de sortie:

0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1001 9
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1010 10
— orlp
source
2
@DDPWNAGE Donnez aux autres un peu de temps pour participer avant d'accepter une réponse :)
— orlp
D'accord, je pensais à l'accepter temporairement, pour que les gens sachent quoi battre.
— DDPWNAGE
2
@DDPWNAGE N'oubliez pas que vous ne pouvez pas facilement refuser une réponse après avoir accepté une réponse et attendu quelques heures.
— FUZxxl
4

Pyth, 19 * 0,8 * 0,8 = 12,16 octets

VSQjd+cjk.[032.BN4N

Exemple de sortie pour l'entrée 5:

0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5

Manifestation.

— isaacg
source
4

Python 2, 48 * 0,8 = 38,4

i=0;exec"i+=1;print format(i,'032b'),i;"*input()

Convertit un nombre en binaire, utilise un formatage de chaîne pour le convertir en binaire avec 32 chiffres, puis imprime également le nombre décimal pour le bonus. Utilise une execboucle pour incrémenter de 1à la valeur d'entrée.

— xnor
source
Bonne solution! Je ne crois pas qu'il a été spécifié, mais cela ne fonctionne pas sur un grand nombre dans la gamme 32 bits: OverflowError: repeated string is too long. Je ne sais pas si c'est une limite pour ma machine.
— Kade
4

APL, 23,68 (37 × 0,8 × 0,8)

{⎕←(⍕⍵),⍨⊃,/,/' ',⍨⍕¨8 4⍴(32⍴2)⊤⍵}¨⍳⎕
— protiste
source
3

KDB (Q), 50 * 0,8 * 0,8 = 32

Je me sens un peu triste avec ma soumission :( Il devrait y avoir une meilleure façon de le faire!

{-1{" "sv raze@'string(0N 4#0b vs x),x}@'1+til x;}

Explication

                                         1+til x     / counting
   {                                  }@'            / lambda each
                      (0N 4#0b vs x),x               / convert to binary and join with input
    " "sv raze@'string                               / convert to string, concatenate each string and join with space
{-1                                             ;}   / print and surpress output in lambda

Tester

q){-1{" "sv raze@'string(0N 4#0b vs x),x}@'1+til x;}5
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0101 5
— WooiKent Lee
source
2
Eh bien, vous pouvez tomber dans K;)k){-1{" "/:,/'$:(0N 4#0b\:x),x}@'1+!x}
— protiste
3

Lisp commun, 96,0

But: (* 150 .8 .8)

(lambda(y)(flet((p(n &aux(x(format()"~39,'0b ~:*~d"n)))(dolist(p'(4 9 14 19 24 29 34))(setf(aref x p)#\ ))(princ x)(terpri)))(dotimes(i y)(p(1+ i)))))

Exemple

Appel de la fonction avec 10:

0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 1001 9
0000 0000 0000 0000 0000 0000 0000 1010 10

Explication

(format()"~39,'0b ~:*~d" #b101010101010) donne:

"000000000000000000000000000101010101010 2730"

La chaîne intermédiaire (un tableau) est modifiée pour mettre un caractère espace aux indices de base zéro suivants: 4 9 14 19 24 29 34. Ensuite, elle est imprimée.

Notez que le (format t"~39,'0,' ,4:b ~:*~d" #b101010101010)format apparemment simple ne fait pas ce que nous voulons. Il imprime:

00000000000000000000000001010 1010 1010 2730

(le rembourrage n'est pas groupé par 4)

— coredump
source
3

Rubis, 28 (35 * 0,8)

?1.upto(*$*){|x|puts"%.32b #{x}"%x}
— addison
source
3

C, 97 * 0,8 * 0,8 = 62,08

a,x;main(b){for(scanf("%u",&b);a++<b;printf("%d\n",a))for(x=32;x--;)printf("%*d",x%-4-2,a>>x&1);}

Exemple de sortie pour l'entrée "5":

0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 1001 9

Je pourrais ajouter un caractère d'espace supplémentaire pour séparer les nombres décimaux des nombres binaires, mais techniquement, le problème ne l'exige pas, je pense? EDIT: Merci, CL!

— Lynn
source
1
Soit dit en passant, vous pouvez remplacer x%-4-1par x%-4-2pour ajouter l'espace entre le binaire et le décimal sans coût supplémentaire en octets. (Cela éliminerait également l'espace supplémentaire au début de chaque ligne.)
— CL-
2

Octave, 23 caractères

dec2bin(1:input(""),32)

Exemple de sortie pour l'entrée 5:

ans =
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101
— user0815
source
2

MatLab, 19 octets

@(x)dec2bin(1:x,32)

Pas trop à celui-ci, MatLab a un convertisseur décimal en binaire intégré et imprime automatiquement le résultat.

— Robby
source
1
Cela n'imprime pas les entiers 32 bits / 64 bits.
— user0815
Désolé, merci pour la tête. J'ai changé le code en conséquence.
— Robby
Cette réponse est presque entièrement identique à la réponse Octave .
— Alex A.
2

Julia, 42 octets

C'est un peu plus court sans les bonus.

n->for i=1:n println(lpad(bin(i),64,0))end

Cela crée une fonction sans nom qui prend un entier et imprime la représentation binaire de chaque nombre de 1 à n , chaque gauche étant rempli de zéros à 64 caractères.

Avec bonus, 78 octets * 0,8 * 0,8 = 49,92

n->for i=1:n for j=1:4:64 print(lpad(bin(i),64,0)[j:j+3]*" ")end;println(i)end

Cela crée une fonction sans nom qui prend un entier et imprime la représentation binaire comme précédemment, cette fois divisée en groupes de 4 avec le nombre en base 10 à la fin.

— Alex A.
source
2

Common Lisp, score: 64,0

100 octets * 0,8 * 0,8

Je suis assez satisfait de mon score, mais je pense toujours qu'il devrait y avoir une possibilité de simplifier un peu mon code.

Production

0000 0000 0000 0000 0000 0000 0000 0001  1
0000 0000 0000 0000 0000 0000 0000 0010  2
0000 0000 0000 0000 0000 0000 0000 0011  3
0000 0000 0000 0000 0000 0000 0000 0100  4
0000 0000 0000 0000 0000 0000 0000 0101  5
0000 0000 0000 0000 0000 0000 0000 0110  6
0000 0000 0000 0000 0000 0000 0000 0111  7
0000 0000 0000 0000 0000 0000 0000 1000  8
0000 0000 0000 0000 0000 0000 0000 1001  9
0000 0000 0000 0000 0000 0000 0000 1010  10

Code

(defun r(n)(dotimes(i n)(format t"~{~a~a~a~a ~}~a~%"(coerce(format()"~32,'0B"(1+ i))'list)(1+ i))))

Explication

Comme décrit dans la réponse de coredump , la chaîne de format

"~32,'0B"

ne produit pas de nombres en base2 mais il semble qu'il n'y ait pas non plus de possibilité de bien regrouper. Par conséquent, je contrains la chaîne dans une liste et j'itère dessus en sélectionnant des groupes de 4 avec cette chaîne de format:

"~ {~ a ~ a ~ a ~ a ~} ~ a ~%"

Après chaque groupe de 4, il y a un blanc et après le dernier groupe, le numéro base10 est imprimé.

Sans regroupement (60x0,8 => 48,0)

(defun r(n)(dotimes(i n)(format t"~32,'0B ~:*~a~%"(1+ i))))

Cela utilise ~: * pour traiter à nouveau l'argument de format (unique).

— Florian Patzl
source
1

PHP, 51,84 (81 × 0,8 × 0,8)

Version 32 bits, car PHP est limité à seulement 32 bits sous Windows, que le système d'exploitation soit 64 bits ou non.

Prend un argument de ligne de commande.

for($i=0;$i++<$argv[1];)echo chunk_split(str_pad(decbin($i),32,0,0),4," ")."$i\n";
— rink.attendant.6
source
1

CoffeeScript, 60,8 (76 × 0,8)

Version 32 bits pour les raisons mentionnées ci-dessus , car CoffeeScript se compile en JavaScript.

f=(x)->console.log(("0".repeat(32)+i.toString 2).slice(-32),i)for i in[1..x]

Avec le regroupement, il devient légèrement plus long: 64,64 (101 × 0,8 × 0,8)

f=(x)->console.log(("0".repeat(32)+i.toString 2).slice(-32).match(/.{4}/g).join(" "),i)for i in[1..x]
— rink.attendant.6
source
1

Haskell, 56 octets

f n=putStr$unlines$take n$tail$sequence$replicate 32"01"

Usage:

*Main> f 5 
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

Pour 64 bits, remplacez le 32par 64. Chaque autre numéro fonctionne aussi.

— nimi
source
1

J, 20 octets

(32#2)#:>:i.".1!:1<1

Exemple d'entrée et de sortie:

3
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
— gar
source
1

Rapide: 98,56 (154 * 0,8 * 0,8)

for x in 1...Int(Process.arguments[1].toInt()!){var p=String(x,radix:2)
let q=count(p)
for i in 0..<32-q{p=(((q+i)%4==0) ?"0 ":"0")+p}
println("\(p) \(x)")}
— addison
source
1

Rubis, 64 bits

70 * 0,8 * 0,8 = 44,8 octets (fractionné, décimal)

1.upto(gets.to_i){|i|puts ("%064d"%i.to_s 2).scan(/.{4}/)*?\s+" #{i}"}

51 * 0,8 = 40,8 octets (décimal)

1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2)+" #{i}"}

67 * 0,8 = 53,6 octets (fractionné)

1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2).scan/.{4}/}

44 octets (pas de bonus)

1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2)}
— taper
source
1

05AB1E , 13 11 octets

Lb32jsäð0:»

-2 octets grâce à @ Mr.Xcoder .

Sorties sans délimiteur d'espace ni numéro de séquence.

Essayez-le en ligne.

Explication:

L              # List of range [1,input]
               #  i.e. 5 → [1,2,3,4,5]
 b             # Convert each to a binary string
               #  i.e. [1,2,3,4,5] → ['1','10','11','100','101']
  32j          # Join everything together with a minimum length per item of 32,
               # which basically prepends spaces to make it length 32
               #  i.e. ['1','10','11','100','101'] → '                               1                              10                              11                             100                             101'
     sä        # Split it into the input amount of parts
               #  i.e. 5 → ['                               1','                              10','                              11','                             100','                             101']
       ð0:     # Replace every space with a 0
               #  i.e. '                             101' → '00000000000000000000000000000101'
          »    # Join everything together by newlines (and output implicitly)
— Kevin Cruijssen
source
1
Lb32jsäð0:»fonctionne pour 11 octets
— M. Xcoder
@ Mr.Xcoder Merci, complètement oublié d'utiliser jle préfixe pour qu'il devienne la bonne longueur.
— Kevin Cruijssen
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.