Замініть свій внесок


19

Це трохи схоже на цей захищений пилом запис, але я сподіваюся, що моє віджимання на ньому робить його досить унікальним. Не вдалося знайти нічого, що мене відштовхує від публікації цього, але там є цілком море.

Все одно! Змагання:

Ваш код отримує рядок символів; Це перетворює це у версію ASCII в художньому стилі тієї ж строки, але з уловкою.

Вхідне перетворення

  • Єдині символи, які підтримуються, - AZ та 0-9
  • Малі літери перетворюються на великі літери
  • Все інше мовчки видаляється

Малюнок символів

  • Кожен "піксель" збільшеного шрифту виводиться із вхідного рядка
  • П'ятий піксель дорівнює п’ятому символу у вхідному рядку. Якщо n більше довжини вхідного рядка, оберніть його назад до початку
  • Окремі букви малюються зліва направо, зверху вниз
  • Подальші літери підбирають індекс "символів пікселів", звідки остання буква залишилася (наприклад, довжина вводу 10, якщо перша буква мала 9 пікселів, перший піксель другої літери буде намальований 10-м символом введення, другий піксель буде намальований першим символом введення)
  • Кожна літера намальована сіткою 5х5, повністю прокладеною пробілами. Ви можете знайти шрифт, який потрібно використовувати для попереднього відображення, в цій пасті або трохи далі в цій публікації
  • Кожна літера намальована в одному рядку, тому загальна кількість розривів рядків у вашому висновку складе 4
  • Кожен лист відокремлюється двома стовпцями пробілів

Шрифт

 000 
0  00
0 0 0
00  0
 000 

111  
  1  
  1  
  1  
11111

2222 
    2
 222 
2    
22222

3333 
    3
  333
    3
3333 

  44 
 4 4 
44444
   4 
   4 

55555
5    
5555 
    5
5555 

 6666
6    
6666 
6   6
 666 

77777
    7
   7 
  7  
 7   

 888 
8   8
 888 
8   8
 888 

 999 
9   9
 9999
    9
9999 

 AAA 
A   A
AAAAA
A   A
A   A

BBBB 
B   B
BBBB 
B   B
BBBB 

 CCCC
C    
C    
C    
 CCCC

DDDD 
D   D
D   D
D   D
DDDD 

EEEEE
E    
EEE  
E    
EEEEE

FFFFF
F    
FFF  
F    
F    

 GGGG
G    
G  GG
G   G
 GGGG

H   H
H   H
HHHHH
H   H
H   H

IIIII
  I  
  I  
  I  
IIIII

JJJJJ
  J  
  J  
  J  
JJ   

K   K
K  K 
KKK  
K  K 
K   K

L    
L    
L    
L    
LLLLL

M   M
MM MM
M M M
M   M
M   M

N   N
NN  N
N N N
N  NN
N   N

 OOO 
O   O
O   O
O   O
 OOO 

PPPP 
P   P
PPPP 
P    
P    

 QQ  
Q  Q 
Q QQ 
Q  Q 
 QQ Q

RRRR 
R   R
RRRR 
R  R 
R   R

 SSSS
S    
 SSS 
    S
SSSS 

TTTTT
  T  
  T  
  T  
  T  

U   U
U   U
U   U
U   U
 UUU 

V   V
V   V
 V V 
 V V 
  V  

W   W
W   W
W W W
WW WW
W   W

X   X
 X X 
  X  
 X X 
X   X

Y   Y
 Y Y 
  Y  
  Y  
  Y  

ZZZZZ
   Z 
  Z  
 Z   
ZZZZZ

Так, я знаю, що 4 і Q некрасиві

Приклад

Вхідні дані

0123456789

Вихідні дані

 012   567    6789   0123     34   45678   9012  34567   234    567 
3  45    8        0      4   5 6   9      3          8  5   6  8   9
6 7 8    9     123     567  78901  0123   4567      9    789    0123
90  1    0    4          8     2       4  8   9    0    0   1      4
 234   12345  56789  9012      3   5678    012    1      234   5678 

Ще один приклад

Вхідні дані

a3 B'2

Вихідні дані

 A3B   B2A3   2A3B   2A3B 
2   A      B  2   A      2
3B2A3    2A3  3B2A    A3B 
B   2      B  3   B  2    
A   3  2A3B   2A3B   A3B2A

Стандартні лазівки заборонені. Код гольфу, так що зелений галочок не буде надано.


17
Я б запропонував гарантувати, що вхід буде містити тільки[A-Z\d] - я не думаю, що фільтрація недійсних символів нічого не додасть до виклику.
Кудлатий

3
@Shaggy Можливо. Але, напевно, я не думаю, що це нічого не знімає з виклику
Scoots



2
А як ТРИ провідні простори? Звичайно, ви цього не дозволите!
Чарівний восьминога Урна

Відповіді:


16

Python 2 , 413 411 373 364 352 345 байт

-1 байт завдяки Kevin Cruijssen .
-9 байт завдяки Джо Кінгу .
-1 байт завдяки Лінні .

Рядок даних містить недруковані версії, опублікована нижче версія.

k=list(filter(str.isalnum,input()))
q=range(5);o=['']*5;r=k*25;d=0
for c in'uM<LxSe#ye>El4NpD@$	gh>I,m]aB>e,]?kFLyglxV!%w832wGj%uT{Hr*K,*[P\n6.&ED#T}^DLI&p7f\d`*lG!FacG\rz?!A':d*=126;d+=ord(c)-1
for c in k:
 for i in q:
	for y in q+[999]*2:o[i]+=d>>int(c,36)*25+i*5+y&1and r.pop(0)or' '
print'\n'.join(o).upper()

Спробуйте в Інтернеті!

Оскільки кожен символ має 25 пікселів, його можна легко закодувати в 25 біт. Основне 126 число 'uM\x04<L\x10x\x14Se#ye\x0f>El4NpD@$\tgh>\x1d\x10\x15I,\x0em]a\x0e\x03B>e\x15,\x0c]\x03?kFL\x01\x0byglxV!\x18\x16\x0c\x0b\x10\x0b%w832wGj%uT{Hr*K,*[P\n6.&ED#T\x0c}^\x1c\x0fD\x17LI&p7\x17f\\d`*\x01l\x1bG\x12!Fac\x05\x08\x0eG\rz?!\x1aA'кодує всі символи, коефіцієнт 0кодується найменш значущими 25 бітами, 1наступними 25 бітами і Zкодується 25 найбільш значущими бітами. Один символ кодується в такому порядку:

00 01 02 03 04
05 06 07 08 09
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24

( 00це найменш значущий біт, 25найзначніший)

Пробіли кодуються нулем, непробіли - одиницею. Приклад :

77777      11111
    7      00001
   7   =>  00010  => (0001000100010001000011111)
  7        00100
 7         01000

Безумовно

k = list(filter(str.isalnum,input()))  # keep only alphanumeric characters of the input
o = ['']*5   # this list contains the output, initially 5 empty lines
r = k * 25   # make a copy of the input 25-times the length, these chars will be used for the pixels
data = 0
#  data encoded in base 126
b92d = 'uM<LxSe#ye>El4NpD@$	gh>I,m]aB>e,]?kFLyglxV!%w832wGj%uT{Hr*K,*[P\n6.&ED#T}^DLI&p7f\d`*lG!FacG\rz?!A'
for c in b92d:          # convert base 92 to base 10
  d*=126;d+=ord(c)-1

for c in k:             # iterate over the filtered input
  a_index = int(c, 36)  # the index of the current char in '0..9A..Z' / '0..9a..z'
  for i in range(5):    # for each row of the output
    for y in range(5)+[999]*2:  # for each pixel in the row, th two 999's are used for spaces
      is_set = data >> (a_index*25 + i*5 + y) & 1  # We shift the to the right to have ...
                                                   # the current pixels value at the LSB:
                                                   # 25 bits for each char that came before
                                                   # 5 bits for each previous row and 1 bit
                                                   # for every pixel in the same row
      o[i] += is_set and r.pop(0) or ' '           # If the current pixel is set, append ...
                                                   # ... a character from the input to the current row
print '\n'.join(o).upper()  # print the output

Спробуйте в Інтернеті!


Літери повинні бути розділені двома пробілами, так і +' 'має бути +' '. Приємна відповідь незалежно, тому +1 від мене.
Кевін Круїйсен

вам .upper()десь потрібно, хоча інакше внутрішні букви закінчуються малими літерами
Jo King

@JoKing Ви маєте рацію, виправте це.
ов

Любіть цей кодуючий трюк. Ви вибрали базу 92, оскільки це найбільше стандартне кодування, що складається з друкованих файлів ascii? ти міг би піти вище? також я в Google, але не зміг уточнити інформацію на базі 92 - у вас є посилання?
Йона

@Jonah Не існує такого стандарту, як базова 92-кодування, тому я реалізував власну логіку декодування. Поки у вас є достатньо чітких цифр, ви можете використовувати будь-яку базу >1.
ов

10

APL (Dyalog Unicode) , 228 225 224 214 байт

Повна програма. Підказки stdin для рядка. Друкується до stdout. Близько половини коду - це просто розшифровка закодованого алфавіту.

⍉↓(⍴t)⍴r\i⍴⍨+/r←,t←(⊂ai←(1(819⌶)⍞)∩a←⎕D,⎕A)⌷0(220⌶)¯1(219⌶)¯125+⎕AV_________________________________________________________________________________________________________________________________________________

__Представляє наступну 143-байтну LZ4-кодовану рядок у лапках:"⊥\u0004pæ€}€\\⊃⌿Æ€â<Å€∧€ÀÆ€Ð┬:Ëcü\u0000≥ðè⊤õ⍨¢∧·èý\u0005þÐÕ\u001EÐ :\u001Eè⌊×ßi[B⊂ɫoãà oéìÐ⍙⊃Ý∣à)≥èB⊃\u001B\u001F⊥ä{⌿⍨ G⍺\u001B⌿Æ\u001F∇x└îR`:└è→⊂\u0000ê∧⍒\u0003ɫqè$$ÛD⊥â∊\u001B\u001Eéu|\u001B@4A|⍪┌nàkááЀ€€€€€€"

Спробуйте в Інтернеті!

__ 143-байт LZ4-закодований рядок у лапках

⎕AV⍳ɩ ndices про те , що в A Tomic V Ector (набір символів)

¯125+ додайте до цього -125 (щоб отримати підписані 8-бітні цілі числа)

¯1(219⌶) Декомпресія LZ4

0(220⌶) десяриалізувати 36-слойний, 5-й рядковий, 5-стовпецький бульовий масив

()⌷ Індексувати, використовуючи наступні індекси:

⎕A верхній регістр A lphabet

⎕D, передбачити D- запали

a← зберігати в a(для більш lphabet)

()∩ Перетин наступного та того (видаляє недійсний вхід):

 запит на введення тексту з stdin (консоль)

  1(819⌶) згорнути в великі регістри ( 819схоже Big, 1 - це так, на відміну від малого)

i← зберігати в i(для i nput)

a⍳ɩ ноти цього вa

 додавати (індексувати кожен, що представляє провідну координату)

t← зберігати в t(для t ext)

, реве (згладжувати)

r← зберігати в r(для r avelled)

+/ сума, що (тобто кількість символів, необхідних для малювання художнього твору)

i⍴⍨циклічно r змініть вхід на цю довжину

r\ розширити, що; вставити пробіли в 0s, вживати літери в 1s

(…) ⍴` переформатуйте до такої форми:

⍴t форма тексту

 розділити масив N-на-5 -5 на N-5-матрицю ліній мистецтва

перенести в 5-за-N матрицю ліній мистецтва (це вирівнює відповідні рядки символів)

За замовчуванням APL відокремлює прості елементи вкладеного масиву з 2 пробілами.


Не зовсім! Між кожною буквою повинно бути 2 пробіли
Scoots

1
@Скотки ОК, виправлено.
Adám

@ Adám щось не так з C і D
ngn

9

Python 2 , 428 байт

s=filter(str.isalnum,input().upper());x=s
R=['']*5
for c in s:
 i=0;exec"n=int('RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDRXDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66YYABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H0000DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N6044AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'[i*36+ord(c)%55%45],36);R[i]+=bin(n+36*(n<30)<<2)[3:].replace(*'0 ').replace(*'1.');i+=1;"*5
 while'.'in`R`:R=eval(`R`.replace('.',x[0],1));x=x[1:]+s
print'\n'.join(R)

Спробуйте в Інтернеті!


Букви кодуються так:

Кожна унікальна частина (їх 23) перетворюється у двійкову, а 1 додається спереду. Потім він перетворюється на базу 36.

  part      bin      1+bin     int     base36
'  ...' -> 00111 -> 100111 ->   39  ->   13

Отримані базові числа 36:

[10,12,13,14,16,18,19,1A,1B,1C,1D,1E,1F,1H,1I,1K,1L,1N,1O,1Q,1R,X,Y]

Початкове 1видалено, тому у нас є один символ:

[0,2,3,4,6,8,9,A,B,C,D,E,F,H,I,K,L,N,O,Q,R,X,Y]

Кожна літера ( A-Z0-9) потім кодується до п'яти цих нових символів.

0 = ' ... ','.  ..','. . .','..  .',' ... ' -> A,F,H,L,A
1 = '...  ','  .  ','  .  ','  .  ','.....' -> O,0,0,0,R
etc.

До п'яти списків:

'AOQQ2RBRAAAQBQRRBDRRDCDDAQ8QBRDDDDDR'
'F0XX6CCXDDDDCDCCCD00ECNLDDEDC0DDD66Y'
'H0A3RQQYABRQCDOOFR00OCHHDQIQA0D6H000'
'L0CXYXD0DXDDCDCCDD00ECDFDCEEX0D6N604'
'ARRQYQA4AQDQBQRCBDRKDRDDAC9DQ0A0DD0R'

Щоб відобразити вхід до індексу в цих списках, порядковий параметр модифікований:

'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ord(c) = [48-57, 65-90]
ord(c)%55%45 = [3-9, 0-2, 10-35]

Оскільки порядки не 0-35, а трохи змішані, 5 списків переставляються та з'єднуються:

'RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDR'
'XDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66Y'
'YABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H000'
'0DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N604'
'4AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'
->
'RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDRXDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66YYABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H0000DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N6044AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'

Для кожного знака у вхідному значенні знайдено 5 букв та перетворено на ints (base36):

n=int('RAAA...D0R'[i*36+ord(c)%55%45],36)
                   i*36                    #get row i
                        ord(c)%55%45       #n -> 0..35
  int(                               ,36)  #convert to int

Якщо число нижче 30, 36додається (відсутнє 1ми видалили раніше)

n+36*(n<30)

Тоді число перетворюється назад у двійкове, а 0s і 1s перетворюються на і .. Під час перетворення додаються два пробіли в кінці.

bin(n+36*(n<30)<<2)[3:].replace(*'0 ').replace(*'1.')

    n+36*(n<30)                                       #add leading base36 '1'
               <<2                                    #add 2 0's to end
bin(              )                                   #convert to binary string
                   [3:]                               #remove '0b1' from front
                       .replace(*'0 ').replace(*'1.') #replace 0 and 1

Напр.

C    base36    int     <<2       bin-str        str
3 ->   13   ->  39  ->  156 -> 0b10011100 -> '  ...  '

Для кожного .результату він замінюється наступним символом із вхідного сигналу (повторений x)

while'.'in`R`:R=eval(`R`.replace('.',x[0],1));x=x[1:]+s

Приємно! Чи можу я заважати вам за пояснення, як це працює? На даний момент це чарівництво для моїх очей.
Scoots

@Scoots На ньому! :)
TFeld

3
Дякую за те, що додали :) Розумність, яку я бачу у відповідях на цьому веб-сайті, ніколи не справляє на мене враження
Scoots

Оскільки деталі складають 5 біт, чому б не використати натомість основу 32?
Ніл

6

Java 8, 917 907 байт

int i,l;String[]S;s->{String q=" ",t="",r[]={t,t,t,t,t};S=s.toUpperCase().replaceAll("[^A-Z0-9]",t).split(t);i=-1;l=S.length;for(String c:S){r[0]+=s("12357BDEFHIJKLMNPRTUVWXYZ",c)+s("012356789ABCDEFGIJOPQRSTZ",c)+s("0123456789ABCDEFGIJOPQRSTZ",c)+s("023456789ABCDEFGIJOPRSTZ",c)+s("567CEFGHIJKMNSTUVWXYZ",c)+q;r[1]+=s("05689ABCDEFGHKLMNOPQRSUVW",c)+s("4MNXY",c)+s("1IJT",c)+s("04KMQXYZ",c)+s("023789ABDHMNOPRUVW",c)+q;r[2]+=s("0456ABCDEFGHKLMNOPQRUW",c)+s("245689ABEFHKPRSV",c)+s("012345689ABEFHIJKMNPQRSTWXYZ",c)+s("23456789ABGHPQRSV",c)+s("0349ADGHMNOUW",c)+q;r[3]+=s("0268ABCDEFGHKLMNOPQRUW",c)+s("0VWXZ",c)+s("17IJTY",c)+s("4KNQRVWX",c)+s("035689ABDGHMNOSUW",c)+q;r[4]+=s("12359ABDEFHIJKLMNPRSWXZ",c)+s("012356789BCDEGIJLOQSUZ",c)+s("01235689BCDEGILOQSTUVYZ",c)+s("012345689BCDEGILOSUZ",c)+s("12ACEGHIKLMNQRWXZ",c)+q;}return"".join("\n",r);}String s(String...s){return s[0].contains(s[1])?S[++i%l]:" ";}

Буде гольф звідси, принаймні, вдвічі зменшивши кількість байтів, сподіваємось.

Спробуйте в Інтернеті.

Пояснення:

int i,                         // Index-integer on class-level
    l;                         // Length-integer on class-level
String[]S;                     // String-array of characters on class-level

s->{                           // Method with String as both parameter and return-type
  String q="  ",               //  Temp String containing two spaces to reduce bytes
         t="",                 //  Temp Empty String to reduce bytes
         r[]={t,t,t,t,t};      //  Start with five empty rows
  S=s.toUpperCase()            //  Transform the input-String to uppercase
     .replaceAll("[^A-Z0-9]",t)//  Remove all non alphanumeric characters
     .split(t);                //  And transform it into a String-array of characters
  i=-1;                        //  Set the index-integer on -1 to start with
  l=S.length;                  //  Set the length of the modified input
  for(String c:S){             //  Loop over the characters of the modified input:
    r[0]+=                     //   Append to the first row:
          s("12357BDEFHIJKLMNPRTUVWXYZ",c)      // The first pixel
          +s("012356789ABCDEFGIJOPQRSTZ",c)     // The second pixel
          +s("0123456789ABCDEFGIJOPQRSTZ",c)    // The third pixel
          +s("023456789ABCDEFGIJOPRSTZ",c)      // The fourth pixel
          +s("567CEFGHIJKMNSTUVWXYZ",c)         // The fifth pixel
          +q;                                   // Two trailing spaces
    r[1]+=                     //   Append to the second row:
          s("05689ABCDEFGHKLMNOPQRSUVW",c)      // The first pixel
          +s("4MNXY",c)                         // The second pixel
          +s("1IJT",c)                          // The third pixel
          +s("04KMQXYZ",c)                      // The fourth pixel
          +s("023789ABDHMNOPRUVW",c)            // The fifth pixel
          +q;                                   // Two trailing spaces
    r[2]+=                     //   Append to the third row:
          s("0456ABCDEFGHKLMNOPQRUW",c)         // The first pixel
          +s("245689ABEFHKPRSV",c)              // The second pixel
          +s("012345689ABEFHIJKMNPQRSTWXYZ",c)  // The third pixel
          +s("23456789ABGHPQRSV",c)             // The fourth pixel
          +s("0349ADGHMNOUW",c)                 // The fifth pixel
          +q;                                   // Two trailing spaces
    r[3]+=                     //   Append to the fourth row:
          s("0268ABCDEFGHKLMNOPQRUW",c)         // The first pixel
          +s("0VWXZ",c)                         // The second pixel
          +s("17IJTY",c)                        // The third pixel
          +s("4KNQRVWX",c)                      // The fourth pixel
          +s("035689ABDGHMNOSUW",c)             // The fifth pixel
          +q;                                   // Two trailing spaces
    r[4]+=                     //   Append to the fifth row:
          s("12359ABDEFHIJKLMNPRSWXZ",c)        // The first pixel
          +s("012356789BCDEGIJLOQSUZ",c)        // The second pixel
          +s("01235689BCDEGILOQSTUVYZ",c)       // The third pixel
          +s("012345689BCDEGILOSUZ",c)          // The fourth pixel
          +s("12ACEGHIKLMNQRWXZ",c)             // The fifth pixel
          +q;}                                  // Two trailing spaces
  return"".join("\n",r);}      //  Return the rows joined with new-lines

//  Separated method with String-varargs parameter and String return-type
String s(String...s){          
  return s[0].contains(s[1])?  //  If the String contains the character-String:
                               //   Increase `i` by 1 first with `++i`
    S[++i%l]                   //   Then return the i'th character of the modified input
                               //   with wraparound by using modulo-`l`
   :                           //  Else:
    " ";}                      //   Return a space

Ви, здається, не маєте автономного прикладу. Класові поля, методи та лямбда. Я поставив +1 тому, що витратив час на це, як очікувалося, але спосіб виглядає дещо недійсним.
Олів'є Грегоар

@ OlivierGrégoire Хм, я вважав, що поля на рівні класу дозволені, якщо ви не встановите їх на рівні класу (функцію потрібно запускати кілька разів, не скидаючи нічого, щоб бути самостійним). Тому я маю i=-1всередині лямбда. Але, можливо, я неправильний, і це не дозволено відповідно до мета? EDIT: Щось подібне робиться досить часто у відповідях на C.
Кевін Круїссен

Не знаю. Ось чому я вжив слово "здається". Але це був би похідний спосіб інстанціювати примітивні значення за замовчуванням, що мають значний вплив на багато відповідей на гольф. Наприклад: int i;f->{for(;i++<10;)print(i);}1 байт коротше f->{for(int i=0;i++<10;)print(i);}.
Олів'є Грегоар

@ OlivierGrégoire Ось чому я заявив, що i=-1це всередині функції лямбда. Ваш приклад не працює, якщо ви запускаєте одну і ту ж лямбда двічі, як і моя, в чому ключова різниця. int i;f->{for(i=0;i++<10;)print(i);}буде дозволено, наприклад (хоча не дуже коротше).
Кевін Кройсейсен

5

Japt v2.0a0 -R, 213 211 210 209 206 193 191 190 байт

Включає провідний пробіл у кожному рядку.

uf \ w
£ `...` ò4 gXn36) nLõd) ¤r0S r1 @ gT ° Ãò5n) ù6Ãy m¸

Спробуйте або протестуйте всі символи (додаткові байти завдяки TIO ще не підтримують Japt v2)


Пояснення

Таблиця пошуку

Кожна група з 4 символів у рядку (представлена ...тут для економії місця і тому, що вона містить купу недрукованих таблиць) - це двійкове представлення кожного символу ( 0для пробілів, 1для символів) з видаленими новими рядками та перетвореними на базову-100.

Приклад

ZZZZZ -> 11111
   Z  -> 00010
  Z   -> 00100 -> 1111100010001000100011111 -> 32575775 -> !::L
 Z    -> 01000
ZZZZZ -> 11111

Кодекс

                                                :Implicit input of string U
u                                               :Uppercase
  f                                             :Get the array of characters matching
   \w                                           : /[a-z0-9]/gi
\n                                              :Reassign to U
£                                               :Map each character as X
 `...`                                          :  The string described above
      ò4                                        :  Split into strings of length 4
          Xn36                                  :  Convert X from base-36 to decimal
         g    )                                 :  Get the element in the array at that index
                Lõ                              :  Range [1,100]
                  d                             :  Get characters at those codepoints
               n   )                            :  Convert from that base to decimal
                    ¤                           :  Convert to binary
                     r0S                        :  Replace all 0s with spaces
                         r1                     :  Replace all 1s
                           @                    :  By passing each match through a function
                             T°                 :    Postfix increment T (initially 0)
                            g                   :    Get the character in U at that index (Yay, index wrapping!)
                               Ã                :  End replacement
                                ò5n)            :  Split into strings of length 5, weighted towards the end
                                    ù6          :  Left pad each with spaces to length 6
                                      Ã         :End mapping
                                       y        :Transpose
                                         m      :Map
                                          ¸     :  Join with spaces
                                                :Implicitly join with newlines and output

4

Ruby , 366 байт

->s{s.tr!('^0-9A-Za-z','');b=([s]*s.size).map(&:chars);%w(esuu6vfveeeufuvvfhvvhghheucufvhhhhhv j411agg1hhhhghgggh44igrphhihg4hhhaa2 l4e7vuu2efvughssjv44sgllhumue4hal444 p4g121h4h1hhghgghh44ighjhgii14hara48 evvu2ue8euhufuvgfhvohvhhegdhu4e4hh4v).map{|x|w=t='';s.chars{|c|c=~/\w/&&w+="%5b  "%x[c.to_i 36].to_i(36)};w.size.times{|i|t+=w[i]>?0?b[i/7].rotate![-1]:' '};t}}

Спробуйте в Інтернеті!

Це можна багато в гольф, але зараз у мене не вистачає часу та ідей. Це було важче, ніж я вперше думав, просто налагодити це.

Як це працює:

Це не так важко зрозуміти, я просто поясню, як алфавіт кодується прикладом. Кожен рядок кожного символу перетворюється у двійковий, а потім у базовий-36.

 AAA   -> 01110 -> E
A   A  -> 10001 -> H
AAAAA  -> 11111 -> V
A   A  -> 10001 -> H
A   A  -> 10001 -> H

Перший крок - вилучення всіх не алфавітно-цифрових символів із вхідного рядка.

Потім я генерую таблицю пошуку для остаточного візуалізації, тому що я хочу надрукувати рядок для рядка.

Після цього, повторюючи алфавітний рядок, я створюю двійковий візерунок літер.

Нарешті я замінюю 0 пробілами та 1 символами з таблиці пошуку.

Не соромтесь далі гольфу, я знаю, що це може бути на 20-30 байт коротше (використання gsub замість tr тощо), але мені зараз це не цікаво, якщо я не можу зробити таблицю алфавітів різко меншою.


4

Вугілля , 172 164 байт

≔⁺⭆χιαα≔Φ↥S№αιθFθ«E⁵⭆§⪪”)∧%"<⁰ETV´el⟧2[◧À&η²p.±‹§K×GR←∨�X¶⌈hF)ξυ9DUuqε↘Z)s⎚H⊙←<¿.&]~b≧✂⪪XïJ61%ZWm/ειK⮌λ﹪▷(σΠNc←º✳Fb⌕⊘¹ÞEpM&➙δl◨α↑j≕ςL¡ρG⁰/y”⁵⁺κ×⁵⌕αι⎇Iμ§θ⊖L⊞Oυω M⁷±⁵

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

≔⁺⭆χιαα

Префікс цифр до попередньо визначеного великого алфавіту.

≔Φ↥S№αιθ

Пропишіть великі літери та відфільтруйте всі непідтримувані символи.

Fθ«

Переведіть петлю на інші символи.

E⁵

Переведіть петлю на кожен рядок, неявно друкуючи кожен результат у власному рядку.

⭆§⪪”...”⁵⁺κ×⁵⌕αι

Стислий рядок - велика ціла константа @ ovs, перетворена у двійкову та обернену назад. Потім він розрізається на 180 підрядів з 5 символів, а відповідна підрядка для поточного символу та рядка перекидається пером.

⎇Iμ§θ⊖L⊞Oυω 

Якщо біт був встановлений, тоді циклічно надрукуйте наступний символ відфільтрованого вводу, інакше надрукуйте пробіл.

M⁷±⁵

Розташуйте курсор готовим до друку наступного символу.


3

Perl 5 з -nlaF/[^A-Za-z0-9]+|/, 247 байт

@l{0..9,A..Z}=unpack("b*",q&....!.?.......G...../.......\....c|...C......'..N.>..c.1~B......I1..~.5.8k....^|!...}.......BH.1..."1..."*FE.....&)=~/.{25}/g;eval'$;[$j%5].=($l{+uc}=~/.{5}/g)[$j++%5]=~s/./$&?uc$F[$i++%@F]:$"/ger.$"x2;'x5for@F;say for@

Спробуйте в Інтернеті!


Пояснення

Спочатку створюється таблиця пошуку при %lвикористанні packданих ed. Ці дані - це 900-бітний двійковий рядок кожного char, упакованого як 25-бітний двійковий рядок (зберігається як 113 байт - лише на 1 байт більше, ніж деревне вугілля!), Подібний до деяких інших відповідей, так Aце:

 AAA 
A   A
AAAAA
A   A
A   A

який, використовуючи 0для простору і 1для A:

01110
10001
11111
10001
10001

і без розривів рядків є:

0111010001111111000110001

Після того , як пошук инициализируются, ми перебирати кожен дійсний напівкокс в @F(який заповнюється з допомогою Perl в -aопції utosplit) , додаючи до кожного з 5 елементів списку @;для кожного рядка в масиві з пошуку, замінюючи все 1з з uc$F[$i++%@F]який є $iй символ (модуль, @Fякий є довжиною @F), перетворений в upper ase c, і всі 0s, з $"яких за замовчуванням розміщується пробіл. Після того, як кожен індекс у @;заповнений для кожного символу @F, sayдрукує кожен рядок із зворотним новим рядком.

Примітка : рядок після unpackмістить недруковані файли, які виводяться за допомогою \xXXпозначення. Перевірка на рахунок 247 .


3

SOGL V0.12 , 165 164 163 байт

⁰CīøDs8↓3‛⁸⁷ω8<t↑\≈⅓dPb¦l═│ƹč<⁷i3ζ°@Ο≠ΖηKπ⁴Φd←⅔Ωī$∞ΧΗf▼xƧqWƨ∑ģpc!ƨ@┐Γ<§5ΛMn«Ιq;⁾№╔1xdψBN≤⁴ζ8□\b╗³╤>↔²Μ±}H}≤╬bφIæ7“2─{rƧ- W}⁰∑M¼nEU{SUZ+;W:?ew;cF+C}X}⁰┌cŗā;{√┼@L*┼

Спробуйте тут!

Пояснення:

...“                 big long number of the character data
    2─               convert to a base 2 string
      {r    }        for each number in it
        Ƨ- W           get it's index in "- ": space for 0, dash for 1
             ⁰∑      join up the results
               M¼n   split into groups of 25 - the letters
                  E  save that in variable E

U{                 }⁰ map over the input uppercased
  SUZ+                  push 1234567890 + the alphabet
      ;W                get the current characters index in that string
        :?       }      duplicate, if not 0 (aka if found)
          e               push the variable E
           w              get in it the duplicated number'th item
                            this leavesleaving the array below the item
            ;             get the array ontop
             cF+C         append the character to the array C
                  X     and remove the top item - either the duplicate or the array

┌             push "-"
 c            load the variable C
  ŗ           cycically replace "-" in maps result with the characters of C
   ā          push an empty array - the output
    ;{        for each item in the result of the replacement
      √         squareify it
       ┼        and append that to the output array
        @L*┼    top-to-bottom, left-to-right add 10 spaces to the array

2

JavaScript (Node.js) , 365 347 байт

Збережено 1 байт завдяки @Scoots

Повертає масив з 5 рядків. Включає провідний пробіл у кожному рядку.

37 36 байтів втрачаються при перетворенні всього на великі регістри та відповідності [A-Z0-9]: - /

a=>(a=a.toUpperCase(s=[...'     ']).match(/[A-Z\d]/g)).map(x=c=>(g=n=>n<35&&g(n+1,s[n<25?n/5|0:n%5]+=Buffer("mJ*Z?<^#?.&+o@V+`L7ho=Jkm?`:Tm)Km?ZZo@p*#MmjoCZ[=('ZoC#;?-g[RZW[>.cJ#Mmm?<^;Vp5[#p*]?,iM#KAm$$:Mm?0*R[#;-46B#qC;o==*X$(km?0-XDc=$.Mm#%]=X$*-?1M[".slice(parseInt(c,36)*(i=v=4))).map(c=>v+=c%80*80**--i)|v>>n&n<25?a[++x]||a[x=0]:' '))(0))&&s

Спробуйте в Інтернеті!

Кодування символів

Символи кодуються догори дном і перетворюються на власну базу-80 зі зміщенням 4 , використовуючи діапазон ASCII [35..114] .

Значення від 35 до 79 безпосередньо відображаються у відповідний символ ASCII, тоді як значення від 0 до 34 відображаються у символах від 80 до 114 . Це дозволяє розшифрувати, просто взявши код ASCII по модулю 80 .

Наприклад, "F" кодується як "RZW[":

....#     00001
....#     00001
..### --> 00111 --> 0000100001001110000111111 --[decimal]--> 1088575 --[-4]--> 1088571
....#     00001
#####     11111

floor(1088571 / 80**3)        = 2    --> (( 2 + 45) mod 80) + 35 = 82  --> 'R'
floor(1088571 / 80**2) mod 80 = 10   --> ((10 + 45) mod 80) + 35 = 90  --> 'Z'
floor(1088571 / 80)    mod 80 = 7    --> (( 7 + 45) mod 80) + 35 = 87  --> 'W'
1088571                mod 80 = 11   --> ((11 + 45) mod 80) + 35 = 91  --> '['

Починаючи з i = v = 4 , він декодується назад до 25-бітного цілого числа, виконуючи:

Buffer("RZW[").map(c => v += c % 80 * 80 ** --i)

У повному коді ми фактично обробляємо необмежений зріз () кодованого потоку, а це означає, що ми, ймовірно, повторимо значно більше, ніж у 4 рази. Це не проблема, тому що всі ітерації з i <0 впливатимуть лише на десяткову частину результату, яка все одно ігнорується побітними операціями, які негайно слідують за цим.

Спробуйте в Інтернеті!


Ви можете замінити toUpperCaseз iпрапором в RegEx?
Кудлатий

@Shaggy Це дозволило б змінити малі символи у висновку, що, на мою думку, не дозволено.
Арнольд

А, схоже, ти маєш рацію, я це пропустив. Найкраще оновити власне рішення!
Кудлатий

1
Чи можете ви зберегти байт шляхом збігу [A-Z\d]замість [A-Z0-9]?
Scoots

1

C (gcc) , 792 690 байт

#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)
i,j,l;main(c,v)char**v;{l=S(v[c=1]);char*x[l],t[l+1],*p=t,*f="$dKqK&>%Q3&R`ms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L`/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]`{+";*x=t;for(;i<l;i++){V>96?V-=32:V;(V>47)&(V<58)|(V>64)&(V<91)?*(p++)=V:V;}*p=0;for(;c<S(t);)x[c++]=((__builtin_popcount(F(t[c-1])+x[c-1]-t)%S(t))+t;for(c=6;--c;){for(i=0;i<S(t);i++){for(j=5,l=1<<c*5+3;j--;)if((l>>=1)&F(t[i]){putchar(*x[i]++);!*x[i]?x[i]=t:x;}else A A A}puts(p);}}

Спробуйте в Інтернеті!

Вдалося вичавити це під 800 з деяким змінним повторним використанням. Вирішив зберігати шрифт як масив ints, так як хоч зберігання його як одна довга струна виглядало як приваблива ідея, тому багато 8-бітових фрагментів шрифту не були приємним зручним символом ASCII, що коди евакуації приймали більше символів ніжint масив.

Редагувати: Отримав менше 700, перейшовши на кодування рядків, все-таки дещо надихнувшись багатьма іншими відповідями тут, я зв'язав базування-92, використовуючи (більшість) символів для друку ASCII. Представлення включає в себе зворотні риски, які потребують додаткового додатку, але це відбувається лише один раз у шрифті.

Крім цього не так вже й багато, що відбувається занадто кричущо - вхід (складається з першого аргументу командного рядка) копіюється в масив стеків за вирахуванням будь-яких символів, які відсутні у шрифті, а малі літери замінені на їх великі версії, який символ "пікселя" починається з кожної повної літери, обчислюється (використання __builtin_popcountмає болісно довге ім'я, але все-таки краще, ніж будь-який метод підрахунку біт, про який я міг придумати), а потім друк проходить по черзі. Компілятор, звичайно, виводить кілька разів тривалість програми у попередженнях.

Нижче деґульгонізовано для задоволення від перегляду:

//The defines are listed here for reference. Some are replaced in the below code but I still use F() because it's long.
#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))  //How to lookup a font character given an input char x
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)                         //Used for looking up the individual parts of a character font
i, j, l;                                           // Declaring some int variables for later use.
main(c,v) char**v; {                               // Declaring afterwards lets us have the int arg default without declaring it
  l = strlen(v[c=1]);                              // Using l as a local variable to shorten S(v[1]) and also giving c an initial value here where there was a spare 1, saving a character over writing the full c=1 init in a later for loop.
  char t[l+1], *p=t, *x[l];                        // Declaring char arrays and char*s and char* arrays. t is oversized if there are any invalid characters in the input, but that's not important for golfing.
  char *f="$dKqK&>%Q3&R`ms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L`/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]`{+";      // The font, encoded base-92 with 5 characters to a letter in the order 0123456789ABCDEF... etc.
  *x=t;                                            // The first character's "pixels" will start at the beginning of the valid input.
  for(; i<strlen(l); i++){                         // Speaking of which, now validate the input.
    v[1][i] > 96 ? v[1][i] -= 32 : v[1][i];        // Change lowercase characters to uppercase. If they aren't actually lowercase characters but have ascii value >96, they won't end up valid after this either and will be edited out on the next line. The false case does nothing, but since with the macro it is one character using the ternary operator saves a character over an if statement even though that case ends up redundant.
    (v[1][i]>47)&(v[1][i]<58)|(v[1][i]>64)&(v[1][i]<91)?*(p++)=v[1][i]:v[1][i];        // If the character is now either a numeral or an uppercase letter, set the next spot in the t array by way of the pointer p and then increment said pointer. 
  }
  *p=0;                                            // Add the null terminator to the t array, our validated input string.
  for(;c<strlen(t);) {                             // Now find out at what index each letter should start getting "pixels" from.
    x[c++] = ((__builtin_popcount(F(t[c-1])+x[c-1]-t)%strlen(t))+t;          // Use the builtin to get the number of on bits/pixels in the previous letter, then add that to the previous letter's starting pixel and take the modulus strlen() of the valid string.
  }
  for(c=6; --c;){                                  // Now start the actual printing. For each line...
    for(i=0; i<strlen(t); i++){                    // For each letter...
      for(j=5, l=1<<c*5+3; j--;) {                 // For each pixel of the 5 on this line...
        if((l>>=1) & F(t[i]) {                     // If it is on...
          putchar(*x[i]++);                        // Print it and increment the pixel-fetching pointer for this letter.
          !*x[i]?x[i]=t:x;                         // If said pointer hit the end of the valid input go back to the beginning.
        } else {
          putchar(32);                             // If it is an off pixel, print a space.
        }
      }
      putchar(32);                                 // After a letter, print two spaces.
      putchar(32);
    }
    puts(p);                                       // This is the cheapest way in character count I could come up with to output a newline. p currently points to the end of t, so it is an empty string and puts just adds a newline.
  }
}


1

Excel VBA, 816 байт

Анонімна функція негайного вікна VBE, яка приймає дані з діапазону [A1] та виводить на консоль.

Наскільки мені відомо, це перша відповідь VBA на використання base64стиснення.

For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While InStr(1,s,"#"):?s

Примітка. Ця відповідь залежить від Microsoft XML, v3.0посилання VBA

Приклад вводу / виводу

[A1]="'0123456789"
For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While i<InStrRev(s,"#"):?s
 012  567   6789  0123    34  45678  9012 34567  234   567  
3  45   8       0     4  5 6  9     3         8 5   6 8   9 
6 7 8   9    123    567 78901 0123  4567     9   789   0123 
90  1   0   4         8    2      4 8   9   0   0   1     4 
 234  12345 56789 9012     3  5678   012   1     234  5678

Необов’язаний і пояснений

Основна частина цього рішення зберігає великий шрифт як базовий рядок 64. Це робиться спочатку перетворенням шрифту у двійковий, де 1представлений on-pixel та 0являє собою off pixel. Наприклад, для 0, це представлено як

      ###     01110
     #  ##    10011
0 -> # # # -> 10101 --> 0111010011101011100101110
     ##  #    11001
      ###     01110

При такому підході буквено-цифрові знаки можуть бути представлені як

0: 0111010011101011100101110    1: 1110000100001000010011111
2: 1111000001011101000011111    3: 1111000001001110000111110
4: 0011001010111110001000010    5: 1111110000111100000111110
6: 0111110000111101000101110    7: 1111100001000100010001000
8: 0111010001011101000101110    9: 0111010001011110000111110
A: 0111010001111111000110001    B: 1111010001111101000111110
C: 0111110000100001000001111    D: 1111010001100011000111110
E: 1111110000111001000011111    F: 1111110000111001000010000
G: 0111110000100111000101111    H: 1000110001111111000110001
I: 1111100100001000010011111    J: 1111100100001000010011000
K: 1000110010111001001010001    L: 1000010000100001000011111
M: 1000111011101011000110001    N: 1000111001101011001110001
O: 0111010001100011000101110    P: 1111010001111101000010000
Q: 0110010010101101001001101    R: 1111010001111101001010001
S: 0111110000011100000111110    T: 1111100100001000010000100
U: 1000110001100011000101110    V: 1000110001010100101000100
W: 1000110001101011101110001    X: 1000101010001000101010001
Y: 1000101010001000010000100    Z: 1111100010001000100011111

Ці сегменти були об'єднані та перетворені в базу 64 MSXML, що представляє

HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=

Підпрограма нижче бере це, назад перетворюється на двійкове, і використовує це посилання, з якого будується вихідний рядок, рядок за рядком, захоплюючи спочатку перші 5 пікселів кожного символу, потім другий рядок і так далі, поки не буде побудовано рядок .

Потім підпрограма перебирається на вихідний рядок і замінює пікселі 'on' символами з вхідного рядка.

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''
''  Embiggen Function
''
''  @Title  :   Embiggen
''  @Author :   Taylor Scott
''  @Date   :   15 June 2018
''  @Desc   :   Function that takes input, value, and outputs a string in which
''              value has been filtered to alphnumerics only, each char is then
''              scaled up to a 5x5 ASCII art, and each 'pixel' is replaced with
''              a char from value. Replacement occurs letter by letter, line by
''              line
''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function EMBIGGEN(ByVal value As String) As String

    Dim DOM         As New MSXML2.DOMDocument, _
        bytes()     As Byte

    Dim isNum       As Boolean, _
        found       As Boolean, _
        index       As Integer, _
        length      As Integer, _
        line        As Integer, _
        letter      As Integer, _
        pos         As Integer, _
        alphanum    As String, _
        char        As String, _
        filValue    As String, _
        outValue    As String

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Filter input
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For letter = 1 To Len(value) Step 1             ''  Iterate Accross `Value`
        Let char = Mid$(UCase(value), letter, 1)    ''  Take the nth char
        ''  If the char is alphnumeric, append it to a filtered input string
        Let filValue = filValue & IIf(char Like "[0-9A-Z]", char, "")
    Next letter
    Let length = Len(filValue)                      ''  store length of filValue

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Convert Constant from Base 64 to Byte Array
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    With DOM.createElement("b64")           ''  Construct b64 DOM object
        Let .DataType = "bin.base64"        ''  define type of object`
        ''  Input constructed constant string shown above
        Let .Text = "HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnz" & _
                     "THGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/" & _
                     "zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc="
        Let bytes = .nodeTypedValue         ''  Pass resulting bytes to array
    End With

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Convert Byte Array to Byte String
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For index = 0 To 112 Step 1
        '' convert each byte to binary, fill left with `0`s and prepend
        Let alphanum = _
            Right("00000" & Evaluate("=Dec2Bin(" & bytes(index) & ")"), 8) & _
            alphanum
    Next index

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Construct Embiggened Binary String of Input Value
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For line = 1 To 5 Step 1                ''  iterate across lines
        For letter = 1 To length Step 1     ''  iterate across letters
            ''  take the corresponding letter from
            Let char = UCase(Mid(filValue, letter, 1))
            If char Like "[0-9]" Then       '' if it is a number,
                ''  Add the 5 bit corresponding to number at line
                Let outValue = outValue & _
                    Mid$(alphanum, 25 * Val(char) + 5 * line, 5) & " "
            ElseIf char Like "[A-Z]" Then   '' if it is a letter,
                ''  Add the 5 bits corresponding to letter at line
                Let outValue = outValue & _
                    Mid$(alphanum, 25 * (Asc(char) - 55) + 5 * line, 5) & " "
            End If
            Next letter
        Let outValue = outValue & IIf(line < 5, vbLf, "")
    Next line
    Let outValue = Replace(Replace(outValue, 0, " "), 1, "#")

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Replace #s with Input Value
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Let pos = 0                             ''  Reset position in filValue
    Let line = 0                            ''  Reset line index
    Let letter = 0                          ''  Reset letter index
    Do
        ''  Find the index of the first `#` starting at line and letter
        Let index = _
            InStr(1 + (line * length + letter) * 6 + line, outValue, "#")
        ''  Iterate position in filValue if a `#` is found in that letter & line
        Let pos = (pos - found) Mod length
        ''  check to see if found index is in the correct letter
        Let found = index < (line * length + letter + 1) * 6 + line
        ''  iff so, replace that # with letter in filValue corresponding to pos
        Let outValue = IIf(found, _
            Left(outValue, index - 1) & _
                Replace(outValue, "#", Mid(filValue, pos + 1, 1), index, 1), _
            outValue)
        ''  if not found, them iterate line
        Let line = line - (found = False)
        ''  iterate letter every five iterations of line
        Let letter = letter - (line > 4)
        ''  Ensure that line between 0 and 4 (inc)
        Let line = line Mod 5
    ''  Loop while there are '#'s in outValue
    Loop While InStr(1, outValue, "#")

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Output
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Let EMBIGGEN = outValue

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Clean Up
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Set DOM = Nothoing
End Function

1

К (нг / к) , 230 231 байт

(+1 байт після зміни мови імп.)

f:{{x,'"  ",/:y}/(#s;5;5)#@[(#c)#"";i;:;(#i:&c:,/(36 25#4_,/+2\a)s)#`c$b s:((b:(48+!10),65+!26)?x-32*(96<x)&x<123)^0N]}

Спробуйте в Інтернеті!

де aцитований рядковий літерал, який кодує шрифт. K бачить рядки як послідовності байтів, тому програма, що містить такий літерал, є дійсною, але вона не може бути запущена в TIO, оскільки її HTML-форма намагається інтерпретувати її як UTF-8 і змінює її.

Кількість байтів обчислюється як:

  • 119 повідомляє TIO

  • -2 для іменування функції f:

  • -1 для заповнювача a

  • 2 для пари цитат ""

  • 113 для довжини літерального рядка, aякий не містить символів, які потребують проходження

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.