64-bitowe tkanie ASCII

18

Wejście

Dwie liczby całkowite:

  • Nieujemna liczba całkowita W w zakresie od 0 do 2 ^ 64-1, określająca splot.
  • Dodatnia liczba całkowita S w zakresie od 1 do 255, określająca długość boku.

Można je wykonać w dowolnej kolejności.

Wynik

S o S ASCII reprezentacji o splocie ( S nowej linii oddzielone ciągi S znaków z opcjonalnym nowej linii tylnej). Splot jest zdefiniowany przez liczbę splotu W w następujący sposób:

Konwertuj W na binarne i podziel na 8 bajtów. Pierwszy (najbardziej znaczący) bajt określa górny rząd, od lewej (najbardziej znaczący bit) do prawej. Następny bajt określa następny wiersz i tak dalej dla 8 wierszy. Liczba splotów określa kwadrat o wymiarach 8 na 8, który należy układać na wymaganym obszarze, zaczynając od lewego górnego rogu. Oznacza to, że jego lewy górny róg powinien odpowiadać lewemu górnemu rogowi obszaru, który ma być objęty.

Każdy 0powinien być wyświetlany jako a |i każdy 1powinien być wyświetlany jako-

Przykłady

Wejście: 0 8

Ouput:

||||||||
||||||||
||||||||
||||||||
||||||||
||||||||
||||||||
||||||||

Wejście: 3703872701923249305 8

Wynik:

||--||--
|--||--|
--||--||
-||--||-
||--||--
|--||--|
--||--||
-||--||-

Wejście: 3732582711467756595 10

Wynik:

||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--

Wejście: 16141147355100479488 3

Wynik:

---
|||
---

Fragment tabeli wyników

(przy użyciu szablonu Martina )

Pokaż fragment kodu

code-golf ascii-art base-conversion tiling trichopaks
źródło

Odpowiedzi:

10

K, 20

{y#y#'"|-"8 8#0b\:x}

.

             0b\:x    // convert to binary
         8 8#         // reshape into an 8x8 boolean matrix
     "|-"             // index into this char vector using the booleans as indices  
  y#'                 // extend horizontally
y#                    // extend vertically

.

k){y#y#'"|-"8 8#0b\:x}[3703872701923249305j;10]
"||--||--||"
"|--||--||-"
"--||--||--"
"-||--||--|"
"||--||--||"
"|--||--||-"
"--||--||--"
"-||--||--|"
"||--||--||"
"|--||--||-"

k){y#y#'"|-"8 8#0b\:x}[3703872701923249305j;8]
"||--||--"
"|--||--|"
"--||--||"
"-||--||-"
"||--||--"
"|--||--|"
"--||--||"
"-||--||-"
tartin
źródło
To naprawdę nie jest prostsze ani prostsze niż to!
JohnE
1
@JohnE Dotyczy to tylko osób, które rozumieją K.;)
Alex A.,
14

CJam, 33 31 bajtów

q~:X;2b64Te["|-"f=8/{X*X<z}2*N*

Sprawdź to tutaj.

Wyjaśnienie

q~      e# Read and eval input.
:X;     e# Store the side length in X and discard it.
2b      e# Convert to base 2.
64Te[   e# Left-pad to length 64 with zeroes.
"|-"f=  e# Select '|' for 0 and '=' for 1.
8/      e# Split into chunks of 8 bits.
{       e# Do the following twice:
  X*    e#   Repeat lines X times (to ensure we have enough of them).
  X<    e#   Truncate them to exactly X lines.
  z     e#   Transpose the grid.
        e#   The transpose ensures that the second pass tiles the columns, and that the
        e#   grid is oriented correctly again after both passes are done.
}2*
N*      e# Join lines by newline characters.
Martin Ender
źródło
2
Oklaskiwam :). To prawdopodobnie najszybsza odpowiedź w historii PPCG
Beta Decay
7
@BetaDecay Zaletą języków golfowych jest to, że masz mniej do pisania, dzięki czemu możesz szybciej pisać. : P
Martin Ender
1
Rany, nawet zadałem sobie trud edycji tagów przed odpowiedzią! Ktoś spędza zbyt dużo czasu na grze w golfa; P
Saber
Czy to zamierzone wyjście: link
Octavia Togami
@Kenzie ten numer wejściowy jest większy niż 2^64-1.
Martin Ender
5

Java, 110 109 107 bajtów

Mój kod ma postać anonimowej funkcji lambda, która przyjmuje a, longa intnastępnie zwraca a String.

(w,s)->{String b="";for(int j,i=s--;i-->0;b+='\n')for(j=s;j>=0;)b+=(w>>8*(i%8)+j--%8)%2<1?'|':45;return b;}

Pełna klasa testowalna

import java.util.function.BiFunction;
public class AsciiWeave {   
    public static void main(String[] args){
        BiFunction<Long,Integer,String> weave = 
            (w,s)->{String b="";for(int j,i=s--;i-->0;b+='\n')for(j=s;j>=0;)b+=(w>>8*(i%8)+j--%8)%2<1?'|':45;return b;}}
        ;
        System.out.println(weave.apply(Long.valueOf(args[0]),Integer.valueOf(args[1])));
    }
}
ankh-morpork
źródło
3
Muszę powiedzieć, że nie jestem przyzwyczajony do bicia przez Javę. : P Dobra robota.
Alex A.,
Dzięki @AlexA.! Lambdas naprawdę sprawiają, że java jest bardziej przydatna do gry w golfa: (w,s)->zamiast tego od String w(long w,int s)razu można oszczędzać.
ankh-morpork
@Ypnypn, które zdecydowanie powinny zadziałać
ankh-morpork
Wow, to imponujące. Dobra robota.
TheNumberOne
4

Matlab, 86 80 bajtów

function f(W,S)
a='|-';x=de2bi(typecast(W,'uint8'))+1;s=8-mod(0:S-1,8);a(x(s,s))

Dzięki Hoki za jego sugestię, która doprowadziła mnie do ocalenia 6 bajtów.

Przykład:

>> W = uint64(3732582711467756595)
W =
  3732582711467756595
>> S = uint8(10)
S =
   10
>> f(W,S)
ans =
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
Luis Mendo
źródło
de2biuratuje ci jeszcze kilka postaci ;-)
Hoki
@Hoki! Dzięki! Myślałem o tym ... ale daje to inną kolejność wyniku
Luis Mendo
tak, musisz wrócić a='|-'do a='-|'. I użyjx=de2bi(typecast(W,'uint8'))+1;
Hoki,
@Hoki Udało mi się dopasować de2bitylko przesunięcie 9-terminu (używane do odwrócenia). Dzięki jeszcze raz!
Luis Mendo,
3

Julia, 145 bajtów

f(w,s)=(A=map(i->i=="1"?"-":"|",reshape(split(lpad(bin(w),64,0),""),8,8))';for i=1:s A=hcat(A,A)end;for i=1:s println(join(A[i>8?i%8:i,1:s]))end)

Tworzy to funkcję, która akceptuje dwie liczby całkowite i wypisuje na standardowe wyjście.

Niegolfowane + wyjaśnienie:

function f(w,s)
    # Convert w to binary, left-padded with zeros to length 64
    b = lpad(bin(w), 64, 0)

    # Create an 8x8 array of | and -
    A = transpose(map(i -> i == "1" ? "-" : "|", reshape(split(b, ""), 8, 8)))

    # Horizontally concatenate A to itself s times
    for i = 1:s
        A = hcat(A, A)
    end

    # Print the rows of A, recycling as necessary
    for i = 1:s
        println(join(A[i > 8 ? i % 8 : i, 1:s]))
    end
end

To jest dość długie i jestem pewien, że można go znacznie skrócić. Pracuję nad tym.

Alex A.
źródło
3

J, 28 bajtów

'|-'{~]$"1]$8 8$_64{.#.inv@[

Stosowanie:

   3732582711467756595 ('|-'{~]$"1]$8 8$_64{.#.inv@[) 10
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--

Objaśnienie (od prawej do lewej):

#.inv@[   binary representation vector of S
_64{.     padded with 0-s from the right to length 64
8 8$      reshaped in an 8 by 8 matrix
]$"1]$    tiled to a W by W size
'|-'{~    select | or - based on matrix element values

Wypróbuj online tutaj.

randomra
źródło
2

Python, 77

lambda w,s:''.join('|-'[w>>~n/s%8*8+~n%s%8&1]+'\n'[~n%s:]for n in range(s*s))

Dla każdej s*swartości n:

  • Oblicz współrzędne za pomocą divmod (i,j)=(n/s,n%s)
  • Oblicz lokalizację w kafelkach jako (i%8,j%8)
  • Oblicz odpowiednią pozycję bitu jako 8*(i%8)+(j%8)
  • Wyodrębnij ten fragment, wprzesuwając wtyle spacji w prawo i weź ostatni kawałek za pomocą &1.
  • Dołącz do jednego z „| -” w tej pozycji
  • Dodaj nowy wiersz na końcu każdego wiersza, ilekroć n%s==0

W rzeczywistości wszystko to kończy się odkładaniem płytki do tyłu, ponieważ czyta się wod końca. Naprawiamy to za pomocą ~nzamiast n. Zamiast tego spróbowałem zastosować podejście rekurencyjne, ale okazało się, że jest nieco dłuższe.

Wyrażenie w>>~n/s%8*8+~n%s%8&1to jest cudem pierwszeństwa operatorów.

xnor
źródło
1

Python 2, 132 bajtów

Z pewnością nie jest to najbardziej eleganckie rozwiązanie i jest niewiele krótsze niż C, ale to początek. Dane wejściowe są oddzielone przecinkami.

k,n=input()
k=[`['|-'[int(x)]for x in'{0:064b}'.format(k)]`[2::5][i*8:i*8+8]*n for i in range(8)]*n
for j in range(n):print k[j][:n]
Kade
źródło
1

C, 160 135 bajtów

i;main(s,v)char**v;{s=atoi(v[2]);for(;i++<s*s+s;)putchar(i%(s+1)?strtoull(v[1],0,10)&1ull<<63-(i/(s+1)*8+(i%(s+1)-1)%8)%64?45:'|':10);}

Można tu jeszcze pograć w golfa i potrzebuję wyjaśnienia, ale w tej chwili nie mam czasu :)

Nie golfowany:

i;

main(s,v)
char**v;
{
    s=atoi(v[2]);
    for(;i++<s*s+s;)
        putchar(i%(s+1) ? /* print dash or pipe, unless at end of row, then print newline */
            /* Calculating which bit to check based on the position is the tough part */
            strtoull(v[1],0,10) & 1ull << 63-(i/(s+1)*8+(i%(s+1)-1)%8)%64 ? /* If bit at correct index is set, print dash, otherwise pipe */
                45 /* dash */
                : '|' /* pipe */
            : 10); /* newline */
}
Cole Cameron
źródło
Czy możesz sformatować tytuł w stylu „C, 100 bajtów”? W ten sposób lepiej pokaże się w tabeli wyników.
Anubian Noob,
Tak, przepraszam za to.
Cole Cameron,
1
Mam problem z prawidłowym działaniem kodu w moim środowisku. Czy kompilujesz się z jakąś konkretną opcją?
ankh-morpork
@ dohaqatar7 Wygląda na to, że niektóre środowiska Linux wymagają stdlib.hwyraźnego włączenia. Nie byłem zmuszony do włączenia go wcześniej, kiedy testowałem na CentOS (myślę, że na tym właśnie byłem). Teraz w Ubuntu nie mogę uruchomić go bez kompilacji:gcc -include stdlib.h w.c
Cole Cameron
Ma
1

Pyth, 31 30 bajtów

L<*QbQjbyyMcs@L"|-".[Z64jvz2 8

Wejście powinny być w dwóch liniach, szer następnie S .

Wypróbuj tutaj

Wyjaśnienie

L                              # define y(b):
  *Qb                          #   b, repeated Q (the second input) times
 <   Q                         #   cut to length Q

                        jvz2   # convert the first input to binary
                   .[Z64       # pad with 0's to length 64
             @L"|-"            # map the digits to the appropriate character
            s                  # convert the list of characters to a string
           c                 8 # chop into 8 strings
         yM                    # extend each string to the correct size
        y                      # extend the list of strings to the correct size
      jb                       # join with newlines
Ypnypn
źródło