Wprowadzenie:

Pamiętam, że kiedy byłem dzieckiem, dostawałem kalkulator i naciskałem +przycisk i sprawdzałem, jak wysoko mogę liczyć. Teraz lubię programować i rozwijam się na iOS.

Liczenie jest podstawową umiejętnością zarówno dla ludzi, jak i komputerów. Bez tego nie można zrobić reszty matematyki. Odbywa się to po prostu od rozpoczęcia 1i powtarzalnego dodawania 1do niego.

Wyzwanie:

To tylko proste wyzwanie. To, co chciałbym, aby twój program zrobił, to wypisywanie z 1tego, Integerco pobiera. Jednak wrzucę w to zwrot, ponieważ liczenie dziesiętne jest trochę nudne:

Liczenie nie może być w bazie 10, musi pokazywać się jako liczenie binarne.

Tak więc, aby policzyć do 5, używając 32-bitowych liczb całkowitych, wyglądałoby to tak:

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

To jest komputer. Oni najlepiej znają binarne. Dane wejściowe mogą być 32-bitową lub 64-bitową liczbą całkowitą. To naprawdę zależy od ciebie. Jeśli jednak używasz 32-bitowych liczb całkowitych, dane wyjściowe muszą być 32-bitowymi liczbami całkowitymi w formacie binarnym , a jeśli używasz 64-bitowych liczb całkowitych, dane wyjściowe muszą być 64-bitowymi liczbami całkowitymi w formacie binarnym .

Przykładowe dane wejściowe:

32-bitowa liczba całkowita, 5

Przykładowe dane wyjściowe:

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

Punktacja:

Twój wynik jest równy liczbie bajtów kodu. Ponieważ jest to Code Golf, wygrywa najniższy wynik.

Punkty bonusowe:

Jeśli wyświetlisz na wyjściu liczbę, pod którą jest to liczba podstawowa 10 (na przykład 0000 0000 0000 0000 0000 0000 0000 0001w systemie binarnym jest równa podstawie 10 1), pomnóż swój wynik przez 0.8.

Jeśli zgrupujesz 4 cyfry wyniku, tak jak ja, pomnóż swój wynik przez 0.8(ponownie). To nie jest wymagane.

Nie zaokrąglać w górę i nie zaokrąglać w dół. Twój wynik jest liczbą zmiennoprzecinkową.

Powodzenia!

code-golf DDPWNAGE
źródło

Czy musisz umieszczać cyfry po cztery, oddzielone spacjami?

xnor 17.07.15

@ xnor Nie. Zrobiłem dla czytelności, ale uwzględnię również bonusową okazję.

DDPWNAGE,

Co się stanie, jeśli użyję typu danych o nieograniczonym rozmiarze ( intna przykład w języku Python 3 )?

isaacg

@isaacg Określ, czy twój program używa 32 lub 64-bitowych liczb całkowitych. Nie musisz uwzględniać liczb całkowitych, które są poza zakresem; musisz tylko wypisać to, co wpisujesz. Innymi słowy, wybór należy do ciebie.

DDPWNAGE,

4

Co się stanie, jeśli nasz język użyje czegoś innego, np. 30-bitowych liczb całkowitych (Haskell) lub liczb całkowitych o dowolnej precyzji (J)?

FUZxxl,

14

APL, 10 znaków

Kolejny włączony w APL. Zakłada ⎕IO←1(domyślnie). Brak punktów bonusowych. Odczytuje liczbę z urządzenia wejściowego. Jeśli twoja APL używa 64-bitowych liczb całkowitych zamiast 32-bitowych liczb całkowitych, zamień 64 na 32 w razie potrzeby.

Zauważ, że APL transparentnie konwertuje na liczby zmiennoprzecinkowe, gdy przekroczony zostanie zakres liczby całkowitej. Trudno jest więc dokładnie powiedzieć, z jaką wielkością całkowitą APL działa.

⍉(32⍴2)⊤⍳⎕

wyjaśnienie

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
źródło

wygląda na to, że nie powinienem tak bardzo starać się o zdobycie 4 grup haha

protist

@protist Nie próbuj zdobywać punktów bonusowych, które są zbyt trudne do wdrożenia. Prawie nigdy nie jest warte wysiłku.

FUZxxl,

Pytanie dotyczyło raczej liczby bajtów niż znaków, więc wynik powinien wynosić 20 bajtów.

ankh-morpork,

@ dohaqatar7 Istnieją kodowania APL (np. strona kodowa 907 ), które pasują do całego zestawu znaków APL w jednym bajcie. Istnieje kilka rozszerzeń APL, których nie można zakodować za pomocą tradycyjnych stron kodowych APL, ale nie używam żadnego z nich.

FUZxxl,

7

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

Wersja 32-bitowa, ponieważ JavaScript nie obsługuje 64-bitowej precyzji (maksymalnie 53 bity przy użyciu podwójnych liczb zmiennoprzecinkowych)

Bez grupowania

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

Z grupowaniem - wynik 60,16 (94 * .64)

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

Testuj w dowolnej przeglądarce (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>

Rozwiń fragment kodu

edc65
źródło

6

Pyth, 18 * 0,8 * 0,8 = 11,52 bajtów

VSQjd+c.[64.BN\04N

Przykładowe dane wyjściowe:

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
źródło

2

@DDPWNAGE Daj innym ludziom czas na rywalizację, zanim zaakceptuje odpowiedź :)

orlp

W porządku, myślałem o tymczasowym zaakceptowaniu tego, aby ludzie wiedzieli, co pokonać.

DDPWNAGE,

2

@DDPWNAGE Pamiętaj, że nie możesz łatwo nie zaakceptować odpowiedzi po jej zaakceptowaniu i odczekaniu kilku godzin.

FUZxxl,

4

Pyth, 19 * 0,8 * 0,8 = 12,16 bajtów

VSQjd+cjk.[032.BN4N

Przykładowe dane wyjściowe dla wejścia 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

Demonstracja.

isaacg
źródło

4

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

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

Konwertuje liczbę na binarną, używa formatowania ciągów, aby przekonwertować ją na binarną z 32 cyframi, a następnie drukuje liczbę dziesiętną premii. Wykorzystuje execpętlę do zwiększania od 1wartości wejściowej.

xnor
źródło

Fajne rozwiązanie! Nie wierzę, że została określona, ale to nie na wielkich liczb w zakresie 32-bitowym: OverflowError: repeated string is too long. Nie jestem jednak pewien, czy to ograniczenie tylko dla mojej maszyny.

Kade,

4

CJam, 13,44 (21 × 0,64)

ri{)_2b64Ue[4/S*S@N}/

Wypróbuj online.

Dennis
źródło

4

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

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

protista
źródło

3

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

Czuję się trochę smutny z powodu mojego zgłoszenia :( Powinien być lepszy sposób, aby to zrobić!

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

Wyjaśnienie

                                         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

Test

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
źródło

2

Cóż, możesz wpaść do K;)k){-1{" "/:,/'$:(0N 4#0b\:x),x}@'1+!x}

Protist

3

Common Lisp, 96,0

Wynik: (* 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)))))

Przykład

Wywołanie funkcji za pomocą 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

Wyjaśnienie

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

"000000000000000000000000000101010101010 2730"

Łańcuch pośredni (tablica) jest modyfikowany w celu umieszczenia znaku spacji w następujących indeksach zerowych: 4 9 14 19 24 29 34. Następnie jest drukowany.

Zauważ, że pozornie prosty (format t"~39,'0,' ,4:b ~:*~d" #b101010101010)format nie robi tego, co chcemy. Drukuje:

00000000000000000000000001010 1010 1010 2730

(wypełnienie nie jest pogrupowane według 4)

rdzeń rdzeniowy
źródło

3

Rubin, 28 (35 * 0,8)

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

addison
źródło

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);}

Przykładowe dane wyjściowe dla wejścia „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

~~Mógłbym dodać jeszcze jeden biały znak, aby oddzielić liczby dziesiętne od liczb binarnych, ale technicznie problem nie wymaga go, tak myślę?~~ EDYCJA: Dzięki, CL!

Lynn
źródło

1

Nawiasem mówiąc można zastąpić x%-4-1z x%-4-2dodać przestrzeń pomiędzy binarny i po przecinku bez dodatkowych kosztów bajtów. (Pozwoliłoby to również pozbyć się dodatkowej przestrzeni na początku każdej linii.)

CL-

2

Oktawa, 23 znaki

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

Przykładowe dane wyjściowe dla wejścia 5:

ans =
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

użytkownik0815
źródło

2

MatLab, 19 bajtów

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

Nie za bardzo, MatLab ma wbudowany konwerter dziesiętny na binarny i automatycznie drukuje wynik.

Robby
źródło

1

To nie drukuje 32-bitowych / 64-bitowych liczb całkowitych.

user0815

Przepraszam, dziękuję za zgłoszenie się. Odpowiednio zmieniłem kod.

Robby,

Ta odpowiedź jest prawie całkowicie identyczna z odpowiedzią Octave .

Alex A.,

2

Julia, 42 bajty

To jest nieco krótsze bez bonusów.

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

Tworzy to nienazwaną funkcję, która przyjmuje liczbę całkowitą i drukuje binarną reprezentację każdej liczby od 1 do n , a każda z lewej jest wypełniona zerami do 64 znaków.

Z bonusami 78 bajtów * 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

Tworzy to nienazwaną funkcję, która przyjmuje liczbę całkowitą i wypisuje reprezentację binarną jak poprzednio, tym razem podzieloną na grupy 4 z liczbą w bazie 10 na końcu.

Alex A.
źródło

2

Common Lisp, wynik: 64,0

100 bajtów * 0,8 * 0,8

Jestem całkiem zadowolony z mojego wyniku, ale nadal uważam, że powinna istnieć możliwość uproszczenia mojego kodu.

Wynik

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

Kod

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

Wyjaśnienie

Jak opisano w odpowiedzi Coredump , ciąg formatu

"~32,'0B"

robi wyjściowe liczby base2, ale wydaje się, że nie ma również możliwości poprawnego zgrupowania. Dlatego przymuszam ciąg do listy i iteruję go, wybierając grupy 4 z tym ciągiem formatu:

„~ {~ a ~ a ~ a ~ a ~} ~ a ~%”

Po każdej grupie 4 jest puste, a po ostatniej grupie drukowany jest numer base10.

Bez grupowania (60 x 0,8 => 48,0)

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

Używa ~: * do ponownego przetworzenia argumentu (pojedynczego) formatu.

Florian Patzl
źródło

1

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

Wersja 32-bitowa, ponieważ PHP jest ograniczony do 32-bitowego systemu Windows, niezależnie od tego, czy system operacyjny jest 64-bitowy.

Bierze jeden argument wiersza poleceń.

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

lodowisko. dozorca 6
źródło

1

CoffeeScript, 60,8 (76 × .8)

Wersja 32-bitowa z wyżej wymienionych powodów , ponieważ CoffeeScript kompiluje się do JavaScript.

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

Zgrupowanie staje się nieco dłuższe: 64,64 (101 × .8 × .8)

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

lodowisko. dozorca 6
źródło

1

Haskell, 56 bajtów

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

Stosowanie:

*Main> f 5 
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

Dla 64bit, wymienić 32się 64. Każda inna liczba też działa.

nimi
źródło

1

J, 20 bajtów

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

Przykładowe dane wejściowe i wyjściowe:

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
źródło

1

Szybki: 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
źródło

1

Ruby, 64-bitowy

70 * 0,8 * 0,8 = 44,8 bajtów (podzielone, dziesiętne)

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

51 * 0,8 = 40,8 bajtów (dziesiętnie)

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

67 * 0,8 = 53,6 bajtów (podzielone)

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

44 bajty (bez bonusów)

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

klaskać
źródło

1

05AB1E , 13 11 bajtów

Lb32jsäð0:»

-2 bajty dzięki @ Mr.Xcoder .

Wyjścia bez separatora spacji ani numeru sekwencji.

Wypróbuj online.

Wyjaśnienie:

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
źródło

1

Lb32jsäð0:»działa na 11 bajtów

Mr. Xcoder,

@ Mr.Xcoder Dzięki, całkowicie zapomniałem o użyciu jdo prepend, aby stał się prawidłowej długości.

Kevin Cruijssen

Licząc od 1 do liczby całkowitej… w formacie binarnym

Wprowadzenie:

Wyzwanie:

Przykładowe dane wejściowe:

Przykładowe dane wyjściowe:

Punktacja:

Punkty bonusowe:

Powodzenia!

Odpowiedzi:

APL, 10 znaków

wyjaśnienie

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

Pyth, 18 * 0,8 * 0,8 = 11,52 bajtów

Pyth, 19 * 0,8 * 0,8 = 12,16 bajtów

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

CJam, 13,44 (21 × 0,64)

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

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

Wyjaśnienie

Test

Common Lisp, 96,0

Przykład

Wyjaśnienie

Rubin, 28 (35 * 0,8)

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

Oktawa, 23 znaki

MatLab, 19 bajtów

Julia, 42 bajty

Z bonusami 78 bajtów * 0,8 * 0,8 = 49,92

Common Lisp, wynik: 64,0

Wynik

Kod

Wyjaśnienie

Bez grupowania (60 x 0,8 => 48,0)

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

CoffeeScript, 60,8 (76 × .8)

Haskell, 56 bajtów

J, 20 bajtów

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

Ruby, 64-bitowy

70 * 0,8 * 0,8 = 44,8 bajtów (podzielone, dziesiętne)

51 * 0,8 = 40,8 bajtów (dziesiętnie)

67 * 0,8 = 53,6 bajtów (podzielone)

44 bajty (bez bonusów)

05AB1E , 13 11 bajtów