19

Ce défi consiste à sortir sur votre terminal, fenêtre, toile ou écran les chiffres de zéro à 10 inclus. Chaque nombre sorti doit être affiché comme un nybble de 4 bits de large, donc zéro doit s'afficher au fur 0000et à mesure.

Vous pouvez séparer chaque numéro émis par un espace, une virgule ou un retour chariot. La plus petite solution l'emporte, mais les chiffres peuvent être affichés dans l'ordre que vous souhaitez tant qu'il n'y a pas de numéros répétitifs dans votre séquence.

Les entrées dans les langages binaires de bas niveau ne doivent pas se soucier des virgules ou des séparateurs d'espaces blancs s'il n'est pas possible de sortir avec des virgules ou des espaces blancs (c'est-à-dire que la sortie standard est limitée au binaire uniquement, ou votre solution est pour un kit informatique précoce comme le KIM-1 qui a un affichage numérique limité).

code-golf kolmogorov-complexity binary Shaun Bebbers
la source

Oui, des espaces, des virgules, une virgule, puis un espace ou un équivalent "\ r \ n" dans la langue de votre choix.

Shaun Bebbers

Pas désolé car cela ressemble à 4 chiffres zéro individuels et non à un nombre binaire large de 4 bits.

Shaun Bebbers

Non pas que je sois vraiment sûr d'écrire une telle réponse, mais serait-il OK de sortir des grignotages supplémentaires en plus des 11 grilles requises?

Arnauld

2

Ce sont des amuse-gueules, pas des agiles.

0WJYxW9FMN

Pas selon le guide de référence des programmeurs Commodore 64

Shaun Bebbers

2

SmileBASIC, 26 octets

FOR I=0TO&HA?BIN$(I,4)NEXT

12Me21
la source

15

MATL , 6 octets

0:10YB

Essayez-le sur MATL Online

Explication

0:10    % Create the array [0...10]
YB      % Convert this array to a binary string where each number is 
        % placed on a new row
        % Implicitly display the result

Suever
la source

15

05AB1E , 9 8 octets

T         # push 10
 4ã       # cartesian product repeat with 4
   R      # reverse list
    T>£   # take the first 11 elements of the list
      »   # join by newline and display

Essayez-le en ligne!

Emigna
la source

10

Attendez ... le produit cartésien des chiffres d'un nombre? C'est juste ...

ETHproductions

13

JavaScript, 46 octets

for(i=15;i++<26;)alert(i.toString(2).slice(1))

Pourquoi utiliser une fonction de remplissage lorsque vous pouvez simplement ajouter 16 à chaque nombre et couper le premier chiffre binaire?

ETHproductions
la source

9

Japt , 7 octets

GôA,_¤Å

Et ici, je pensais que Japt était voué à être plus long que toutes les autres langues de golf ...

Testez-le en ligne!

Explication

GôA,_¤Å  // Implicit: A = 10, G = 16
GôA      // Create the inclusive range [G...G+A].
    _    // Map each item Z to Z
     ¤   //   .toString(2)
      Å  //   .slice(1).
         // Implicit: output result of last expression

Normalement, les virgules peuvent être supprimées dans Japt, mais celui-ci est là à cause d'un bogue: _signifie normalement function(Z){Z, mais pour une raison quelconque, le compilateur pense que cela A_signifie function(A,Z){Z.

ETHproductions
la source

Joli. Je suis resté coincé àAô_¤

Oliver

8

Utilitaires Bash + GNU, 26

4 octets enregistrés grâce à @Dennis

seq -w 0 1010|sed /[2-9]/d

Essayez-le en ligne .

Traumatisme numérique
la source

1

seq -w 0 1010devrait marcher.

Dennis

@Dennis Merci - Je ne me souviens pas avoir utilisé l' -woption seqavant.

Digital Trauma

7

Utilitaires Bash + Unix, 29 26 octets

dc -e2o8927II^*8/p|fold -4

Essayez-le en ligne!

C'est la même longueur que la solution de @ DigitalTrauma / @ Dennis, mais utilise une méthode complètement différente.

La sortie est:

(Toute commande est autorisée.)

Pure Bash , 34 octets

echo 0{0,1}{0,1}{0,1} 10{00,01,10}

Essayez la version pure Bash en ligne!

La sortie est:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

Mitchell Spector
la source

7

J, 6 octets

#:i.11

Merci aux miles pour l'avoir réduit à 6 octets!

Blocs
la source

#:i.11devrait fonctionner aussi bien

miles

Je ne suis pas sûr que ce soit valide, selon la réponse à un commentaire maintenant supprimé .

Adám

@ Adám, je ne peux pas le voir. Pourriez-vous s'il vous plaît expliquer pourquoi ce n'est pas vaild?

Bloque

Parce qu'il génère un tableau booléen × 4, qui s'imprime sous forme de chiffres avec des espaces entre les deux. Mais le commentaire semble impliquer que les espaces ne sont pas autorisés à l'intérieur des nombres binaires.

Adám

6

Gelée , 7 octets

2Bṗ4ṫ6Y

Essayez-le en ligne!

(5 octets si les lignes de fin de Nybbles sont autorisées, 2Bṗ4Y )

Comment?

Imprime dans l'ordre décroissant.

2Bṗ4ṫ6Y - Main link, no arguments
2B      - 2 converted to binary -> [1,0]
  ṗ4    - Cartesian 4th power -> [[1,1,1,1], [1,1,1,0], ..., [0,0,0,0]]
                            i.e.  16       , 15         ..., 0
    ṫ6  - tail from 6th item  -> [[1,0,1,0], [1,0,0,1], ..., [0,0,0,0]]
                            i.e.  10       , 9        , ..., 0
      Y - join with line feeds
        - implicit print

Une alternative à 7 octets est 2ṗ4Ịṫ6Y, la [1,0]est remplacée par [1,2]et Ịest la monade ( abs(z)<=1) est "insignifiante" , convertissant 2s en 0s.

Jonathan Allan
la source

6

Python 3.6, 36 35 octets

i=11
while i:i-=1;print(f"{i:04b}")

-1 octet grâce à @JonathanAllan

Python 3.5 et versions antérieures:

i=11
while i:i-=1;print("{:04b}".format(i))

Essayez-le en ligne!

ovs
la source

1

i=11(nouvelle ligne) while i:i-=1;print(f"{i:04b}"), pour 35.

Jonathan Allan

4

PHP, 33 octets

while($i<11)printf('%04b ',$i++);

user63956
la source

4

CJam , 12 octets

B{G+2b1>}%N*

Essayez-le en ligne!

Explication

L'approche cartésienne du pouvoir aurait été mon choix, mais a déjà été retenue.

Donc, cela génère des nombres de 0 à 10, et pour chacun, il ajoute 16 et convertit en binaire. L'ajout de 16 garantit que les zéros de tête requis sont produits, ainsi qu'un autre de tête qui est supprimé.

B             e# Push 11
 {      }%    e# Map over "11", implicitly converted to the array [0 1 ... 10]
  G+          e# Add 16. This makes sure there will be 5 binary digits: a leading 1
              e# which will have to be removed and the remaining, valid digits
    2b        e# Convert to array of binary digits
      1>      e# Remove first digit
          N*  e# Join by newlines. Implicitly converts arrays to strings

Luis Mendo
la source

3

MATLAB / Octave, 13 octets

dec2bin(0:10)

Démo en ligne

Suever
la source

3

Gelée , 10, 9 , 8 octets

⁴r26BḊ€Y

Essayez-le en ligne!

Je ne suis pas si bon en gelée, donc je serais ouvert à tous les conseils!

Cela utilise le premier algorithme d'Emigna

Merci à Dennis d'avoir ~~rasé deux octets,~~ ce qui m'a fait lier sa propre réponse. : P

Explication:

      Ḋ€    # Return all but the first element of each item in the list:
⁴r26        #   [16, 17, 18, ... 26]
     B      #   Converted to binary
        Y   # And joined with newlines

DJMcMayhem
la source

Ḋ€enregistre un octet.

Dennis

@Dennis Ah, c'est logique. Merci!

DJMcMayhem

⁴r27enregistre un autre.

Dennis

3

Python 2 , 38 36 octets

n=16;exec"print bin(n)[3:];n+=1;"*11

Merci à @DJMcMayhem d'avoir joué au golf sur 2 octets!

Essayez-le en ligne!

Dennis
la source

for n in range(11):print bin(n+16)[3:] also at 38 bytes.

ETHproductions

n=16;exec"print bin(n)[3:];n+=1;"*11 is two shorter

DJMcMayhem

@DJMcMayhem It is indeed. Thanks! :)

Dennis

2

Jelly, 8 bytes

2Ḷṗ4ḣ11Y

Try it online!

How it works

2Ḷṗ4ḣ11Y  Main link.

2Ḷ        Unlength 2; yield [0, 1].
  ṗ4      Take the fourth Cartesian power.
    ḣ11   Head 11; discard all but the first eleven elements.
       Y  Join, separating by linefeeds.

Dennis
la source

2

RProgN, 15 Bytes

~16.aL1{2B26q}:

~~This has been a very good modivation to add a pad function. The entirety of ]L4\-'0'\m\., more than half the code, is to pad.~~

_Saved 6 bytes thanks to @ETHProductions, that's the pad function cut in half.

Explained

~16.aL1{2B26q}:
~               # Zero Space Segment
 16.            # The literal number 16
    aL          # The length of the Alphabet
      1         # The literal number 1
       {     }: # For each number between 16 and 26 inclusive
        2B      # Convert to base 2
          26q   # Get the characters between 2 and 6 inclusive.

Try it online!

ATaco
la source

length of the Alphabet Nice way to save a byte ;-)

ETHproductions

2

Retina, 36 33 bytes


%%%%
+`(^|\b)%
0$%'¶$%`1
11!`\d+

Try it online!

Explanation


%%%%

Replace the empty (non-existent) input with %%%%.

+`(^|\b)%
0$%'¶$%`1

On the first run of this stage, it will match ^% and essentially replace the text %%%% with the two lines 0%%% and 1%%%. The stage will loop until the output stops changing. On the second run, it will match \b% (since digits count as word characters and % doesn't), and replace the groups by duplicating them and adding 0 to one copy and 1 to the other: 0%%% becomes the lines 00%% and 01%% (and the same sort of thing for 1%%%). Through this loop all 16 bitstrings will be produced, linefeed separated.

11!`\d+

The first 11 matches of \d+ (a run of at least 1 digit) are retrieved. The matches are output in a linefeed-separated list.

Business Cat
la source

I'm curious in understanding how this 0$%'¶$%1` line works. What do $%, `1, '¶ represent?

Kritixi Lithos

@KritixiLithos Sorry I didn't explain the specifics, it's a bit convoluted :P. $%` represents everything before the match on the same line, and $%' is everything after the match on the same line. ¶ is a literal linefeed. So basically the replacement matches the first % on a line and replaces it with 0 plus the rest of the line it was on, a newline, the beginning of the line it was on, and a 1. Of course, the beginning and end of the line it was on are untouched by the replacement because they weren't part of the match.

Business Cat

So it's not putting a copy of the line after itself, but rather inserting the end of the line, a newline, and the beginning of the line in between the beginning and end of the line that remain intact.

Business Cat

Ah thanks, that was helpful :) (I'm trying to learn Retina now)

Kritixi Lithos

In which case, I think you can use G11` as the last line of the regex instead

Kritixi Lithos

2

Ruby, 25 bytes

11.times{|n|puts"%04b"%n}

G B
la source

2

BF, 121 101 bytes

,....>,.<...+.>.<-..+.-.>.<..+..>.<-.+.-..>.<.+.-.+.>.<-.+..-.>.<.+...>.<.-...>.<+.-..+.>.<.-.+.-.!0

Requires a trailing newline. Makes use of ! symbol (so, check the box that says !) with this interpreter (try it online!).

Potentially 51 bytes if each operator was considered as 4 bits

Timtech
la source

You should specify (or additionally add a byte) for the ! checkbox being enabled.

Conor O'Brien

Whoops, I'm new to that and thought it encoded it in the URL. Will specify... wait, actually, I think it's already specified in the second sentence (?), will clarify that a bit

Timtech

2

C#, 96 bytes

Golfed

()=>{for(int i=0;i++<11;)System.Console.WriteLine(System.Convert.ToString(i,2).PadLeft(4,'0'));}

Ungolfed

() => {
    for( int i = 0; i++ < 1; )
        System.Console.WriteLine( System.Convert.ToString( i, 2 ).PadLeft( 4, '0' ) );
}

Full code

using System;

namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            m();

            Console.ReadLine();
        }

        static void m() {
            for( Int32 i = 0; i++ < 11; )
                Console.WriteLine(
                    Convert.ToString( i, 2 ). // Converts the number to binary code
                    PadLeft( 4, '0' ) );      // Fills the number with the missing '0's
        }
    }
}

Releases

v1.0 - 96 bytes - Initial solution.

auhmaan
la source

I like the release version you added - are you going to include RC versions as well? \o/

Shaun Bebbers

1

Going to be honest, don't know what RC means... This is how I try to post my solutions in PPCG

auhmaan

RC means 'Release Candidate' - i.e., you'd send out a few versions with minor differences and await to see which is the most stable by your RC number. So if you had version A and version B, you could have v1.0-RCa and v1.0-RCb or something.

Shaun Bebbers

1

Oh, that. No. If I make another release, I increment the Version Number right away.

auhmaan

2

C 170 120 bytes

n,i,m,k[4]={0};f(){for(m=0;m<=10;m++){n=m;i=0;for(;n;i++){k[i]=n;n/=2;}for(i=4;i>0;i--)printf("%d",k[i-1]%2);puts("");}}

Ungolfed version:

void f()
{
    int n,i,m,k[4]={0};


   for(m=0;m<=10;m++)
   {
      n=m;
      i=0;

      for(;n;i++)
      {
         k[i]=n;
         n/=2;
      }  
      for(i=4;i>0;i--)
         printf("%d",k[i-1]%2);

      puts("");        
   }
}

Can definitely be shortened!?

@Ahemone Awesome idea, Thanks!

Should work now! Try it online!

Abel Tom
la source

the first for loop in your golfed version should go to 4 rather than 3, but that doesn't matter because the loop can be eliminated entirely and the second for loop can start from 0. You can also just use while(n), but compacting the while loop down into a for loop saves more again. n/=2 will also save you a byte over the shift. You're also missing a terminating } on the golfed version causing an error on compilation.

Ahemone

@Ahemone Fixed the } and improved the code, 50 bytes shorter based on your idea.

Abel Tom

102 bytes

ceilingcat

2

R - 23

We can use intToBin function from the R.utils package:

R.utils::intToBin(0:10)

[1] "0000" "0001" "0010" "0011" "0100" "0101" "0110" "0111" "1000" "1001" "1010"

bouncyball
la source

2

C, 75 68 69 bytes

Approach 1: 75 73 74 bytes

m;p(i){putchar(i?m&i?49:48:9);}r(){for(m=11;m--;p(4),p(2),p(1),p(0))p(8);}

Try it online!

Approach 2: 68 69 bytes

m,n,o;f(){for(m=11;m--;)for(n=m,o=5;o--;n*=2)putchar(o?n&8?49:48:9);}

Try it online!

Ahemone
la source

Suggest m,n;f(o) instead of m,n,o;f()

ceilingcat

1

Python 2, 44 bytes

for x in range(11):print bin(x)[2:].zfill(4)

This uses the zfill function which works like rjust except it always padds with 0 so you don't waste bytes on an argument.

Wheat Wizard
la source

Wait what, this whole time I've been wasting bytes making my own padding function? (lambda k,l:' '*(len(k)-l)+k) Wow... +1 just because of this :D

HyperNeutrino

1

Pyke, 8 bytes

TFw0+b2t

Try it here!

TFw0+b2t - for i in range(10):
  w0+    -    i+16
     b2  -   bin(^)
       t -  ^[:-1]

Also 8 bytes:

TF 4@b2t

Try it here!

   4@    - set_bit(4, i)

Blue
la source

1

Pyth - 8 7 bytes

<5^_`T4

Try it online here.

Maltysen
la source

1

stacked, 30 bytes

11:>[2 baserep'0'4 pad out]map

Try it online!

11:> is a range from 0 to 10. The rest is rather self-explanatory.

Ruby, 38 bytes

11.times{|i|puts i.to_s(2).rjust 4,?0}

dkudriavtsev
la source

-1 byte by getting rid of the parentheses: 11.times{|i|puts i.to_s(2).rjust 4,?0}

Conor O'Brien

1

BF, 134 bytes

I'm sure this can be shortened--it's pretty much my first BF golf.

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

Try it online! Assumes a tape infinite in both directions, like the interpreter at TIO uses. An interpreter where < at the left end of the tape is a no-op would save three bytes.

Explanation

More than half of the code (the first 77 bytes, to be precise) is spent initializing the tape. The steps go like this:

++++++++++
10|

[>+>+>+++++>>>+++++>>>+++++>>>+++++[<<<]>>>-]
 0|10|10|50| 0| 0|50| 0| 0|50| 0| 0|50|

>>+>[-->>+>]<<<[<<<]>>
 0|10|11|48| 0| 1|48| 0| 1|48| 0| 1|48| 0| 1|

The cells initialized to 1 store the bits of our number plus 1: 1 represents a zero bit and 2 represents a one bit.

The initialization phase ended with the pointer on the 11. Now we use this cell to run 11 iterations of our loop:

[>          Move to the first 48
 [>>-       While we're still on a 48, move 2 cells over and decrement
  [         The cell's value now equals the bit it represents; if it's not 0:
   <<+.-    Move to the 48, increment, output, and decrement again
   >        Move to the next cell, which holds a 0
  ]         Leave the loop
  <[>]>     Pointer shenanigans to get back on the cell representing the bit
  -         Decrement again: cell is 255 for a zero bit, 0 for a one bit
  [         If cell is not 0:
   <<.>     Move to the 48, output, and move to the 0 cell
  ]
  <[>]>++   Get back on the bit's cell; increment back to original value
  >         Move to the next 48
 ]          Loop exits once we've output all four bits
            Now we increment the binary number: a one bit turns into a zero bit and
            carries; a zero bit turns into a one bit and doesn't carry
 <-         Move back to the rightmost bit cell and decrement
 [          If it is not 0, it must represent a one
  <<<-      Leave it decremented, go to the next bit cell and decrement it too
 ]          Loop exits on a bit cell that represented a zero
 ++         Increment it twice (to represent a one)
 <<[<<<]    Move back to first cell on tape
 >.         Move to 10 cell and output (newline)
 >-         Move to loop counter cell and decrement
]

DLosc
la source

Compter en nybbles binaires

Réponses:

SmileBASIC, 26 octets

MATL , 6 octets

05AB1E , 9 8 octets

JavaScript, 46 octets

Japt , 7 octets

Explication

Utilitaires Bash + GNU, 26

Utilitaires Bash + Unix, 29 26 octets

Pure Bash , 34 octets

J, 6 octets

Gelée , 7 octets

Comment?

Python 3.6, 36 35 octets

Python 3.5 et versions antérieures:

PHP, 33 octets

CJam , 12 octets

Explication

MATLAB / Octave, 13 octets

Gelée , 10, 9 , 8 octets

Python 2 , 38 36 octets

Jelly, 8 bytes

How it works

RProgN, 15 Bytes

Explained

Retina, 36 33 bytes

Ruby, 25 bytes

BF, 121 101 bytes

C#, 96 bytes

C 170 120 bytes

R - 23

C, 75 68 69 bytes

Python 2, 44 bytes

Pyke, 8 bytes

Pyth - 8 7 bytes

stacked, 30 bytes

Ruby, 38 bytes

BF, 134 bytes

Explanation