Wypełnij mój arkusz bąbelków

18

Dzisiaj był dzień rejestracji do egzaminu AP w mojej szkole i chociaż skrupulatnie bulgotałem na stronach i wymaganych stronach z informacjami, wpadłem na pomysł tego wyzwania. Tak więc, biorąc pod uwagę ciąg liter i cyfr, wypisz odpowiednio wypełniony wykres bąbelkowy.

Zasady:

  • Dla każdego znaku w ciągu wejściowym zamień ten znak w odpowiedniej kolumnie na #lub @inny rozsądny symbol (jeśli twój język może to obsłużyć, znak Unicode „full_block”: █ wygląda naprawdę dobrze)
  • Spacja jest reprezentowana przez pustą kolumnę (patrz przykłady)
  • Poprawnym wprowadzeniem będzie ciąg znaków, który składa się tylko z wielkich liter, cyfr i spacji.
  • Dane wejściowe będą miały długość minimum 1 i maksymalnie 32 znaki.
  • Dane wyjściowe muszą być duże
  • Jeśli długość wejściowa jest mniejsza niż maksymalna długość 32, twój program musi nadal wypisywać pozostałe puste kolumny
  • Twój program nie musi obsługiwać małych liter tak samo, jakby były dużymi literami, ale punkty bonusowe, jeśli to możliwe.

Format płyty:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

Przykłady:

CODE GOLF ->

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
█CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DD█DDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEE█EEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFF█FFFFFFFFFFFFFFFFFFFFFFF
GGGGG█GGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLL█LLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
O█OOOO█OOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999


ABCDEFGHIJKLMNOPQRSTUVWXYZ012345 ->

@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
B@BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CC@CCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDD@DDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEE@EEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFF@FFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGG@GGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHH@HHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIII@IIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJ@JJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKK@KKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLL@LLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMM@MMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNN@NNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOO@OOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPP@PPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQ@QQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRR@RRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSS@SSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTT@TTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUU@UUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVV@VVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWW@WWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXX@XXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYY@YYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZ@ZZZZZZ
00000000000000000000000000@00000
111111111111111111111111111@1111
2222222222222222222222222222@222
33333333333333333333333333333@33
444444444444444444444444444444@4
5555555555555555555555555555555@
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ->^^^

I oczywiście jest to golf golfowy , więc wygrywa najkrótsza odpowiedź

code-golf  ascii-art 
— X1M4L
źródło
7
Sprawdzanie poprawności danych wejściowych jest ogólnie odradzane, więc możesz po prostu dopasować dane wejściowe [A-Z0-9]{1,32}i zezwolić na dowolne zachowanie danych wejściowych, które nie są zgodne.
— Giuseppe,
1
Jak absurdalnie denerwujący jest fakt, że „0” występuje przed „A” w kodzie ASCII> :( lol
— NL628
„Poprawnym wprowadzeniem będzie ciąg znaków, który składa się ze znaków pojawiających się na arkuszu bąbelkowym, a także spacji”, ale podaje się również „Dowolny znak inny niż wielkie litery, spacje i cyfry lub powyżej limitu 32 znaków należy zignorować ” , więc który to jest?
— Kritixi Lithos
1
Ale zgodnie z pierwszym stwierdzeniem mówisz, że $nie pojawi się w danych wejściowych
— Kritixi Lithos
1
Po usunięciu cyfr i niepoprawnych znaków ze specyfikacji możesz także usunąć je z przykładów.
— Tytus,

Odpowiedzi:

4

Łuska , 23 bajty

mż§?'#|=⁰mR32¤+…"AZ""09

Wypróbuj online lub wypróbuj fantazyjną postać but (ale nieprawidłową liczbę bajtów)!

Niestety nie udało mi się połączyć dwóch maps w jedno (z wyjątkiem użycia nawiasów, co kosztuje 24 bajty) ..

Wyjaśnienie

mż§?'#|=⁰mR32¤+…"AZ""09"  -- expects string as argument, eg. "FOO"
             ¤            -- with the two strings "AZ" "09" ..
               …          -- | fill ranges: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          -- |              "0123456789"
              +           -- .. and concatenate: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
          m               -- map the following (eg. with 'X')
                          -- | replicate 32 times: "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                          -- : ["A…A","B…B",…,"Z…Z","0…0",…"9…9"]
m                         -- map the following (eg. with "F…")
 ż      ⁰                 -- | zipWith (keeping elements of longer list) argument ("FOO")
  §?   =                  -- | | if elements are equal
    '#                    -- | | | then use '#'
      |                   -- | | | else use the first character
                          -- | : ["#FF…F"]
                          -- : ["A…A",…,"#FF…F",…,"O##O…O",…,"9…9"]
— ბიმო
źródło
4

Rubin , 62 bajty

->s{[*?A..?Z,*?0..?9].map{|c|(0..31).map{|i|c==s[i]??@:c}*''}}

Wypróbuj online!

Zwraca tablicę ciągów. Można by dalej grać w golfa, odrzucając łączenia ciągów i zwracając tablicę znaków 2D, jak to zwykle jest normą, ale nie jestem pewien, czy jest to dozwolone tutaj.

— Kirill L.
źródło
3

C (gcc) , 132 126 bajtów

char*s="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",*_,*a;f(char*x){for(_=s;*_;++_,puts(""))for(a=s;*a;)putchar(x[a++-s]-*_?*_:64);}

Wypróbuj online!

Podziękowania dla Jonathana Frecha za uratowanie 6 bajtów.

— LambdaBeta
źródło
puts("")jest równoważne z putchar(10).
— Jonathan Frech,
++a)putchar((x[a-s]-*_)?*_:64);-> )putchar(x[a++-s]-*_?*_:64);.
— Jonathan Frech,
Jeśli chcesz trochę nagiąć reguły, możesz także zagrać 64w golfa 1.
— Jonathan Frech,
Jeśli to zrobisz, putcharpołączenie można zagrać w golfa putchar(*_*(*_!=a[x-s]));.
— Jonathan Frech,
Normalnie nie miałbym nic przeciwko naginaniu reguł ... ale 1 to zupełnie inna bestia niż wypełniony prostokąt lub znak @. Inne zmiany są jednak przydatne - zaktualizują się.
— LambdaBeta,
3

Czerwony , 177 bajtów

func[s][m: copy[]foreach c a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[insert/dup r: copy"^/"c 32 append m r]j: 0
foreach c s[j: j + 1 if c <>#" "[m/(index? find a c)/(j): #"@"]]m]

Wypróbuj online!

Bardziej czytelny:

f: func[s][
    m: copy[]
    a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    foreach c a[
        insert/dup r: copy "^/" c 32
        append m r
    ]
    j: 0
    foreach c s[
        j: j + 1
        if c <>#" "[m/(index? find a c)/(j): #"@"]
    ]
    m
]
— Galen Iwanow
źródło
3

Węgiel drzewny , 21 bajtów

Ｅ⁺α⭆…αχκ⭆…◨θφ³²⎇⁼ιλ#ι

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

  α  α                  Uppercase alphabet predefined variable
      χ                 Predefined variable 10
    …                   Chop to length
   ⭆                    Map over characters and join
       κ                Current index
 ⁺                      Concatenate
Ｅ                       Map over characters into array
           θ            Input string
            φ           Predefined variable 1000
          ◨             Right pad to length
             ³²         Literal 32
         …              Chop to length
        ⭆               Map over characters and join
                 ι  ι   Current outer character
                  λ     Current inner character
                ⁼       Equals
                   #    Literal `#`
               ⎇        Ternary
                        Implicitly print each result on its own line

Poprzednia wersja z weryfikacją danych wejściowych, 34 32 bajty. Edycja: zapisano 2 bajty dzięki tylko @ ASCII.

≔⁺α⭆…αχκαＥα⭆…◨Φθ∨⁼ι №αιφ³²⎇⁼ιλ#ι

Wypróbuj online! Link jest do pełnej wersji kodu.

— Neil
źródło
: / Wygląda na to, że brakuje ci zamkniętych paren na końcu
— tylko ASCII
To wygląda jak to działa. (Wolfram StringReplace) Na marginesie: wbudowana zamiana byłaby bardzo przydatna, prawda
— tylko ASCII
Nieważne, nie wiem co robiłem. 27 bajtów - nie potrzebujeszCast
— tylko ASCII
Ponadto, re: pad z dowolnym znakiem, o który pytałeś wcześniej: czy uważasz, że przydałoby się to dodać jako wbudowane? a może jako wbudowany dwuznakowy?
— Tylko ASCII,
23
— Tylko ASCII,
3

Galaretka ,  18  17 bajtów

ØA;ØDWẋ32ɓ,€⁶y"ZY

Używa znaku spacji. Aby użyć #zastąpić ⁶z”# na koszt jednego bajta.

Wypróbuj online!

W jaki sposób?

ØA;ØDWẋ32ɓ,€⁶y"ZY - Main Link: list of characters, S   e.g.  ['S','P','A','M']
ØA                - upper-case alphabet characters           ['A','B',...,'Z']
   ØD             - digit characters                         ['0','1',...,'9']
  ;               - concatenate                              ['A','B',...,'Z','0','1',...,'9']
     W            - wrap in a list                           [['A','B',...,'Z','0','1',...,'9']]
      ẋ32         - repeat 32 times                          [['A','B',...,'Z','0','1',...,'9'],...,['A','B',...,'Z','0','1',...,'9']]
         ɓ        - start a new dyadic chain with that on the right
            ⁶     - space character                          ' '
          ,€      - pair €ach of S with a space              [['S',' '],['P',' '],['A',' '],['M',' ']]
              "   - zip with:
             y    -   translate (replace 'S' with ' ' in 1st, 'P' with ' ' in 2nd, ...) -- Note: zip is a zip-longest, so trailing lists remain
                Z  - transpose
                 Y - join with line-feeds
                   - implicit print
— Jonathan Allan
źródło
Mogę zapisać jeden bajt.
— Erik the Outgolfer
Welp, mam również ³Ḣ,⁶yØA;ØD¤µ32СZY18 lat, które, moim zdaniem, również mogą być ulepszone! Wychodzę jednak ...
— Jonathan Allan
Oczywiście nie o tym mówię. :) Spróbuj bardziej ...
— Erik the Outgolfer
Niesamowite, że udało mi się zagrać w golfa na komórkach 17 bajtów
— Jonathan Allan
Mój był właściwie taki , ale gratulacje!
— Erik the Outgolfer
2

C ++ 14, 319 bajtów 237

To pierwszy raz, kiedy robię to w najgorszym możliwym języku CodeGolf: P

char c;string k="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",s;int main(){map<char,vc>g;g[' ']=vc(32,' ');for(char c:k)g[c]=vc(32,c);getline(cin,s);for(int i=0;i<s.length();i++)g[s[i]][i]='@';for(char d:k){for(char x:g[d])cout<<x;cout<<'\n';}}

Wypróbuj online!

— NL628
źródło
Pytanie: Czy muszę dołączyć nagłówek?
— NL628,
Jeśli konieczne jest uruchomienie kodu, musi on znajdować się w Twojej odpowiedzi. To powiedziawszy, możesz usunąć prawie wszystkie białe znaki i nadal mieć tę odpowiedź.
Czy mogę przepisać to jako funkcję z parametrami zamiast main ()?
— NL628,
@ NL628 tak, możesz. Aby uzyskać więcej pomocy, zobacz wskazówki dotyczące gry w golfa w C ++ . EDYCJA: przełączono link do C ++
— Giuseppe
1
COBOL ktoś? Nigdy nie napisałem w nim wiersza kodu, ale użycie COBOL-a do golfa kodowego może być ciekawym wyzwaniem.
— Hans-Martin Mosner
2

Node.js, 85 bajtów

Port do Node.js sugerowany przez @DanielIndie

f=(s,x=544,c=Buffer([48+x/32%43]))=>x<1696?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

Wypróbuj online!

JavaScript (ES6), 103 98 bajtów

f=(s,x=544,n=x>>5,c=String.fromCharCode(48+n%43))=>n<53?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

Wypróbuj online!

— Arnauld
źródło
90 bajtów, co powiesz na to?
— DanielIndie,
@DanielIndie Thanks! Dodany. (Naprawdę tego nie potrzebujemy +"", prawda?)
— Arnauld,
Nigdy nie wiem, czy musimy konwertować, czy nie, więc nie myślę o tym: P, ale tak naprawdę nie potrzebujesz tego :)
— DanielIndie
@DanielIndie Ah, teraz możemy po prostu użyć, x/32aby zapisać 2 kolejne bajty, ponieważ Bufferwymusza to liczby całkowite.
— Arnauld,
f=(s,x=561,c=Buffer([48+x/33%43]))=>x<1749?(s[x++%33]==c?'@':x%33?c:`\n`)+f(s,x):''
— l4m2
2

Haskell , 86 bajtów

Aby uzyskać znacznie ładniejsze podejście (i mniej bajtów), zobacz rozwiązanie Laikoni !

f x=(x#).(<$[1..32])<$>['A'..'Z']++['0'..'9']
(a:b)#(u:v)=last(u:['#'|a==u]):b#v
_#w=w

Wypróbuj online!

Alternatywnie dla tej samej liczby bajtów moglibyśmy użyć:

(a:b)#(u:v)|a==u='#':b#v|0<3=u:b#v

Wypróbuj online!

Wyjaśnienie / Niegolfowany

Operator (#)jest bardzo podobny do zipWithtej funkcji, jednak funkcja jest zakodowana na stałe, st. używa, #jeśli dwa znaki są równe, a w przeciwnym razie zachowuje drugi, nie golfisty:

(a:b) # (u:v)
   | a == u    = '#' : b # v
   | otherwise =  u  : b # v

Jeśli pierwsza lista jest wyczerpana, po prostu dołącza pozostałe elementy drugiej:

_ # w = w

Za pomocą tego pomocnika musimy tylko wygenerować ciąg "A..Z0..9", replikować każdy element 32 razy i spakować dane wejściowe każdym ciągiem, bez golfa:

f x = map ((x#) . replicate 32) (['A'..'Z'] ++ ['0'..'9'])
— ბიმო
źródło
1
85 bajtów: Wypróbuj online!
— Laikoni
@Laikoni: Szkoda, że ​​to tylko 1 bajt mniej, to naprawdę sprytne użycie max. Myślę, że powinieneś opublikować to jako własne rozwiązanie, ponieważ bardzo różni się od mojego rozwiązania.
— ბიმო
Opublikowałem wersję 74-bajtową .
— Laikoni
2

Haskell , 74 bajty

f x=[do a<-take 32$x++cycle" ";max[c]['~'|a==c]|c<-['A'..'Z']++['0'..'9']]

Wypróbuj online! Łańcuch wejściowy xjest wypełniony spacjami do długości 32 za pomocą take 32$x++cycle" ". Dla każdego znaku cod Ado Zi 0do 9, patrzymy na znaki az wypełnionego ciągu wejściowego i zastępujemy je, ~kiedy ai csą równe, i cinaczej. Osiąga się to poprzez max[c]['~'|a==c], np. max "A" "~" = "~"Kiedy a = c = 'A', a max "A" "" = "A"kiedy c = 'A'i a = 'B'. Ponieważ daje to ciąg singletonu zamiast znaku, doużywana jest adnotacja, która łączy ciąg singletonu w jeden ciąg.

Na podstawie rozwiązania BMK firmy Haskell .

— Laikoni
źródło
2

Python 2, 138 bajtów

Obsługuje zarówno wielkie jak i małe litery oraz pozostawia niewypełnioną kolumnę dla spacji.

def f(s):
 s=s.upper()
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))

Jeśli bonus nie jest tego wart, wybiorę 125 bajtów i będę obsługiwał tylko duże litery:

def f(s):
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))
— sonrad10
źródło
2

Stax , 15 bajtów

╛dδÑ-═E↑\≈Fà±AG

Uruchom i debuguj

To używa '#' do wskazania wypełnionego bąbelka.

Rozpakowane, niepolowane i skomentowane, wygląda to tak.

32(     right-pad or truncate to 32
{       begin block for mapping
  VAVd+ "A..Z0..9"
  s'#+  move input character to top of stack and append "#". e.g. "C#"
  |t    translate; replace the first character with the second in string
m       perform map using block
Mm      transpose array of arrays and output each line

Uruchom ten

— rekurencyjny
źródło
1

Pyth, 23 20 bajtów

j.Tm:s+r1GUTdN.[Qd32

Wypróbuj tutaj

Wyjaśnienie

j.Tm:s+r1GUTdN.[Qd32
              .[Qd32      Pad the input to 32 characters.
   m                      For each character...
     s+r1GUT              ... get the string "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"...
    :       dN            ... with the character replaced by a '"'.
j.T                       Transpose the lines and print them all.
1

APL + WIN, 56 bajtów

Monituje o ciąg wejściowy i używa # znaku jako identyfikatora:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10]⋄((,m[;1]∘.=32↑⎕)/,m)←'#'⋄m

Wyjaśnienie:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10] create the table

32↑⎕ pad the input string to 32 characters with spaces

(,m[;1]∘.=32↑⎕) use outer product with = to identify characters in table

((,m[;1]∘.=32↑⎕)/,m)←'#' replace characters with #

m display table

⋄ statement separator
— Graham
źródło
1

C (gcc) , 124 bajty

f(s,b,x,y)char*s,b[33];{sprintf(b,"%-32.32s",s);for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),s=b;*s;putchar(*s++==y?35:y));}

Wypróbuj online!

Zamiast tablicy zakodowanej na stałe zastąpiłem ją funkcją wyszukiwania. Na szczęście zestaw znaków ASCII ma ciągłe zakresy alfabetyczne i numeryczne (patrzę na ciebie, EBCDIC!) Również upewniłem się, że dane wyjściowe mają dokładnie 32 znaki, używając sprintf(): jeśli nie było to wymaganiem zadania, funkcja miałaby 97 bajtów:

f(s,i,x,y)char*s,*i;{for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),i=s;*i;putchar(*i++==y?35:y));}

Wypróbuj online!

— ErikF
źródło
— ceilingcat
1

CJam , 31 bajtów

q32Se]{'[,65>A,s+S+_@#St);}%zN*

Wypróbuj online! Używa spacji jako znaku „dołka”.

Jeśli końcowe białe znaki są dozwolone, działa to dla 29 bajtów :

q32Se]{'[,65>A,s+S+_@#St}%zN*

Wypróbuj online!

Oto 34-bajtowa odmiana, która █zamiast tego używa pełnego bloku Unicode ( ):

q32Se]{'[,65>A,s+S+_@#'█t);}%zN*

Wypróbuj online!

Wyjaśnienie

q                                Input.
    e]                           Pad to a length of
 32                                32
                                 with
   S                               spaces.
      {                   }%     For each character:
                                   Get the uppercase alphabet by
            >                        dropping the first
          65                           65
                                     elements of
         ,                             the range of characters below
       '[                                '['.
                +                  Append
               s                     the string version
              ,                        of the range of numbers below
             A                           10.
                  +                Append
                 S                   a space.
                     #             Find the index of
                    @                the character.
                       t           Set this index to
                      S              a space
                   _               in the original array.
                        );         Drop the space at the end.
                                   Yield this modified array.
                                 End for. The result is an array of arrays of characters.
                            z    Transpose this array, turning rows into columns.
                             N*  Join the result on newlines.
— Esolanging Fruit
źródło
1

05AB1E , 19 bajtów

RтúR32£vžKuÙyð:})ø»

Wypróbuj online!

Wyjaśnienie

R                     # reverse
 тú                   # prepend 100 zeroes
   R                  # reverse
    32£        }      # take the first 32 characters
       v              # for each character
        žK            # push a string of [a-zA-Z0-9]
          uÙ          # upper case and remove duplicates
            yð:       # replace current character with space
                )ø    # transpose
                  »   # join by newline
— Emigna
źródło
a[b]nie działa tak, jak tego chcesz, prawda: P?
— Magic Octopus Urn
@MagicOctopusUrn: Niestety nie. To była moja pierwsza myśl, ale modułowe indeksowanie nie jest naszym przyjacielem w tym przypadku: P
— Emigna
1

MATL , 21 bajtów

1Y24Y2vjO33(32:)y=~*c

Używa spacji jako znaku znacznika.

Wypróbuj online!

Wyjaśnienie

1Y2     % Push 'AB...YZ'
4Y2     % Push '01...89'
v       % Concatenate into a 36×1 column vector of chars
j       % Push unevaluated input: string of length n, or equivalently 1×n
        % row vector of chars
O33(    % Write 0 at position 33. This automatically writes a 0 at postions
        % n+1, n+2, ..., 32 too
32:)    % Keep only the first 32 entries: gives a 1×32 row vector
y       % Duplicate from below: pushes a copy of the 36 ×1 column vector
=~      % Test for non-equal entries, with broadcast. Gives a 33×32 matrix
        % containing 0 for matching entries, and 1 otherwise
*       % Multiply this matrix by the 1×32 row vector, with broadcast. This
        % changes each 1 into the corresponding character in the input
c       % Convert to char. Implicitly display. Char 0 is displayed as space
— Luis Mendo
źródło
1

Common Lisp , 150 bajtów

(setq s(format nil"~32a"(read-line)))(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

Wypróbuj online!

Wyjaśnienie

;; pad input to 32 spaces on the right
(setq s(format nil"~32a"(read-line)))
;; for each character in bubble sheet, for each character in input:
;; if characters are equal print "#"
;; else print bubble sheet character
(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
— Tylko ASCII
źródło
1

Java 10, 120 118 117 bajtów

s->{var r="";for(char c=65,i;c<91&c!=58;r+="\n",c+=c<90?1:-42)for(i=0;i<32;i++)r+=i<s.length&&s[i]==c?35:c;return r;}

Wypróbuj online (dla TIO użyłem „█” ( 9608zamiast 35) dla lepszej widoczności).

Wyjaśnienie:

s->{                   // Method with character-array parameter and String return-type
  var r="";            //  Result-String, starting empty
  for(char c=65,i;     //  Start character `c` at 'A'
      c<91&c!=58       //  Loop as long as `c` is 'Z' or smaller, and is not '9'
      ;                //    After every iteration:
       r+="\n",        //     Append a new-line to the result-String
       c+=c<90?        //     If `c` is not 'Z' yet
           1           //      Go to the next character ASCII-value-wise
          :            //     Else:
           -42)        //      Change the 'Z' to '0'
    for(i=0;i<32;i++)  //    Inner loop `i` in the range [0,32)
      r+=i<s.length    //     If we're not at the end of the input array yet,
         &&s[i]==c?    //     and the characters in the column and array are the same
          35           //      Append the filler-character '#'
         :             //     Else:
          c;           //      Append the current character instead
  return r;}           //  Return the result-String
— Kevin Cruijssen
źródło
1

Siatkówka , 64 bajty

$
36* 
L`.{36}
.
36*@$&¶
Y`@`Ld
(.)(.*)\1
@$2
N$`\S
$.%`
L`.{32}

Wypróbuj online!

$
36* 
L`.{36}

Uzupełnia łańcuch wejściowy po prawej stronie spacjami do 36 znaków

.
36*@$&¶
Y`@`Ld

Następnie umieść każdy znak w osobnej linii i dodaj ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789przed nim.

(.)(.*)\1
@$2

Dopasuj parę tego samego znaku w tej samej linii, która jest jedna wtedy i tylko wtedy, gdy znak dla tej linii pasuje do jednego z nich ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789. Zamień pierwszy na @i usuń drugi.

N$`\S
$.%`

Jedynymi niedopasowanymi liniami są linie ze spacjami, więc znaki spacji to blok kwadratowy 36 × 36. Transponuj to.

L`.{32}

Zachowaj tylko pierwsze 32 znaki w każdym wierszu

— TwiNight
źródło
1

Tcl , 153 145 bajtów

Dzięki @sergiol za -8 bajtów

lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {puts [join [lmap j [split [format %-32s [join $argv ""]] ""] {expr {$i==$j?"#":$i}}] ""]}

Wypróbuj online!

Wyjaśnienie

# for i in list of choices
lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {
    # print string of
    puts [join
        # list of
        [lmap j
             # for each character in first argument padded to 32 characters
             [split [format %-32s [join $argv ""]] ""]
             # return "#" if current choice and current character are equal, else current choice
             {expr {$i==$j?"#":$i}}
        ]
        ""
    ]
}
— Tylko ASCII
źródło
152
— sergiol
@sergiol: | Tak to jest. 146 ?
— Tylko ASCII,
1
145
— Tylko ASCII,
1

SNOBOL4 (CSNOBOL4) , 155 150 bajtów

	I =INPUT
	U =&UCASE '0123456789'
N	U LEN(1) . K REM . U	:F(END)
	O =DUPL(K,32)
	X =
S	I LEN(X) @X K	:F(O)
	O POS(X) K =' '	:S(S)
O	OUTPUT =O	:(N)
END

Wypróbuj online!

Wyjaśnienie:

	I =INPUT			;* read input
	U =&UCASE '0123456789'		;* U = uppercase concat digits
N	U LEN(1) . K REM . U	:F(END)	;* while U not empty, pop first letter as K
	O =DUPL(K,32)			;* dup K 32 times
	X =				;* set position to 0
S	I LEN(X) @X K	:F(O)		;* find the next occurrence of K and save (index - 1) as X
	O POS(X) K =' '	:S(S)		;* replace the X'th occurrence of K with space. If that's before character 32, goto S, else proceed to next line
O	OUTPUT =O	:(N)		;* output the string and goto N
END
— Giuseppe
źródło
1

Prolog (SWI) , 235 229 228 222 214 198 173 167 165 bajtów

-6 bajtów dzięki kwakowi @Cows , -6 bajtów dzięki @ 0 ' 

X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
_+[].
X+[H|T]:-H*X,X+T.
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.

Wypróbuj online!

Wyjaśnienie

% if head = bubble char, write "#", else write bubble char, then while tail is non-empty, recurse.
% if tail is empty then print newline
X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
% if list is empty, then do nothing. this prevents t from being called with invalid X
_+[].
% call t, then recurse for each char in list
X+[H|T]:-H*X,X+T.
% read, pad input to 32 chars, and convert input to list
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.
— Tylko ASCII
źródło
0

Oktawa , 61 bajtów

@(s)[((a=[30:55 13:22]'*~~(o=1:32)).*(a+35~=[s o](o)))+35 '']

Wypróbuj online!

Funkcja działa w następujący sposób:

@(s)[                                                     ''] %Anonymous function, taking string, outputting character array   
         [30:55 13:22]'                                       %Creates the board alphabet ('A':'Z' '0':'9']) but minus 35 (value of '#')
                       *~~(o=1:32)                            %Matrix multiplication by an array of 32 1's to form the 2D board. Saves 1:32 for later.
      (a=                         )                           %Saves the board mimus 32 to a for use later.
                                            [s o](o)          %Ensures the input is 32 characters long. Missing chars replaced by 1:32 (not in board)
                                     (a+35~=        )         %Compares against board (a+35 as a=board-35). Makes 2D array where matches = 0, others = 1. 
     (                             .*                )+35     %Element=wise multiplication, forcing matches to 0. Then add 35 resulting in board with #'s
— Tom Carpenter
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.