ความท้าทาย:

สำหรับอินพุตของตัวอักษร X หนึ่งตัว (ตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กจาก A ถึง Z) และหนึ่งหลัก N (0-9) พิมพ์ตัวอักษร X ที่สอดคล้องกันที่ทำจาก N * X

จดหมายต้องมาจากรายการนี้:

 AAA      BBBB       CCCC     DDDD      EEEEE     FFFFF      GGG      H   H
A   A     B   B     C         D   D     E         F         G         H   H
AAAAA     BBBB      C         D   D     EEEE      FFFF      G  GG     HHHHH
A   A     B   B     C         D   D     E         F         G   G     H   H
A   A     BBBB       CCCC     DDDD      EEEEE     F          GGG      H   H


IIIII         J     K   K     L         M   M     N   N      OOO 
  I           J     K  K      L         MM MM     NN  N     O   O
  I           J     KKK       L         M M M     N N N     O   O
  I       J   J     K  K      L         M   M     N  NN     O   O
IIIII      JJJ      K   K     LLLLL     M   M     N   N      OOO 


PPPP       QQQ      RRRR       SSSS     TTTTT     U   U     V   V     W   W
P   P     Q   Q     R   R     S           T       U   U     V   V     W   W
PPPP      Q   Q     RRRR       SSS        T       U   U     V   V     W   W
P         Q  QQ     R  R          S       T       U   U      V V      W W W
P          QQQQ     R   R     SSSS        T        UUU        V        W W 


X   X     Y   Y     ZZZZZ
 X X       Y Y         Z 
  X         Y         Z  
 X X        Y        Z   
X   X       Y       ZZZZZ

ตัวอย่าง:

อินพุต: 1

เอาท์พุท:

 AAA
A   A
AAAAA
A   A
A   A

อินพุต: A 0

เอาท์พุท: A

อินพุต: A 2

เอาท์พุท:

      AAA  AAA  AAA
     A   AA   AA   A
     AAAAAAAAAAAAAAA
     A   AA   AA   A
     A   AA   AA   A
 AAA                 AAA
A   A               A   A
AAAAA               AAAAA
A   A               A   A
A   A               A   A
 AAA  AAA  AAA  AAA  AAA
A   AA   AA   AA   AA   A
AAAAAAAAAAAAAAAAAAAAAAAAA
A   AA   AA   AA   AA   A
A   AA   AA   AA   AA   A
 AAA                 AAA
A   A               A   A
AAAAA               AAAAA
A   A               A   A
A   A               A   A
 AAA                 AAA
A   A               A   A
AAAAA               AAAAA
A   A               A   A
A   A               A   A

อินพุต: A -1

เอาท์พุท: อะไรที่เคย: มันไม่สำคัญ

กฎเพิ่มเติม:

• พารามิเตอร์อินพุตสามารถคั่นด้วยอักขระที่คุณต้องการ
• ตัวอักษรแต่ละตัวจะต้องใช้ทุนของตัวเองเป็นตัวละคร ASCII เพื่อวาด
• อนุญาตให้เว้นวรรคต่อท้ายบรรทัดใหม่และอื่น ๆ
• แทนที่จะเป็นโปรแกรมคุณอาจเขียนฟังก์ชั่นที่รับสายอักขระตัวเลขเป็นอาร์กิวเมนต์ ควรพิมพ์ออกตามปกติ
• Stdout / Stderr ไม่สำคัญเพียงเลือกหนึ่งรายการ หากสิ่งที่พิมพ์บน gots อื่น ๆ ไม่สำคัญเช่นกัน
• รูปแบบเอาต์พุตที่เป็นไปได้สามารถพิมพ์ไปที่ STDOUT คืนค่าเป็นรายการสตริงส่งคืนเป็นเมทริกซ์อักขระเป็นต้นตราบใดที่ผลลัพธ์สามารถพิมพ์ได้โดยใช้วิธีการพิมพ์ที่เป็นค่าเริ่มต้นของภาษา *

*: เช่นเดียวกับฟังก์ชั่น f (a, 1) ส่งคืนสตริงและหนึ่งสามารถพูดว่า print (f (a, 1)) ไม่ต้องทำการพิมพ์ () เรียกส่วนของคำตอบ (สิ่งนี้ชี้ให้เห็นโดย Kevin Cruijssen และ Arnauld)

ชนะ:

นี่คือรหัส - กอล์ฟชนะน้อยที่สุดนับไบต์ มีความสุข!

แก้ไข : คำถามนี้ดูเหมือนกันมากกับเรื่องนี้แต่ฉันจะบอกว่ามันไม่ได้เป็นเพราะมันไม่ควรทำงานสำหรับ H แต่สำหรับตัวอักษรแต่ละตัวจากตัวอักษร .. เดาว่าคุณตัดสินใจที่จะทำซ้ำหรือไม่

JavaScript (ES8), 281 ไบต์

(letter)(N)จะเข้าเป็น ส่งคืนสตริง

c=>n=>(g=y=>y--?''.padEnd(w).replace(/./g,(_,x)=>(h=d=>~~(d/=5)?(P=parseInt)('hhvhefhfhfu111ufhhhfv1f1v11f1vehp1ehhvhhv444vehgggh979hv1111hhlrhhpljhehhhe11fhfuphheh9fhffge1u4444vehhhh4ahhhalhhhha4ah444ahv248v'[y/d%5+5*P(c,36)-50|0],36)>>x/d%5&1?h(d):' ':c)(w))+`
`+g(y):'')(w=5**n)

ลองออนไลน์!

อย่างไร?

การเข้ารหัสแบบอักษร

$5\times5$$0$$31$

รูปแบบที่เก็บไว้จะถูกทำมิเรอร์ทั้งแนวนอนและแนวตั้ง

ตัวอย่างสำหรับ 'F':

#####     ....#     00001      1     '1'
#....     ....#     00001      1     '1'
####. --> .#### --> 01111 --> 15 --> 'f' --> '11f1v'
#....     ....#     00001      1     '1'
#....     #####     11111     31     'v'

$26\times5 = 130$

$(x,y)$$n^{\text{th}}$

parseInt('hhvhefhfh...'[y + 5 * n], 36) >> x & 1

อัลกอริทึมหลัก

$n$$w=5^n$

$0\le x<w$$0\le y<w$$(x,y)$$h$

$k$$[0 \dots n-1]$

ฟังก์ชันส่งคืนช่องว่างทันทีที่ตรวจพบพิกเซลว่างที่ระดับความลึกบางส่วนหรืออักขระที่สอดคล้องกับตัวอักษรอินพุตหากการวนซ้ำทั้งหมดสำเร็จ

R , 348 ไบต์

function(K,N){if(N)for(i in 1:N)T=T%x%matrix(c(15269425,32045630,16269839,32032318,33061407,33061392,15224366,18415153,32641183,1082926,18444881,17318431,18732593,18667121,15255086,32045584,15255151,32045649,16267326,32641156,18400814,18400580,18400938,18157905,18157700,32575775)[utf8ToInt(K)-64]%/%2^(24:0)%%2,5,5)
write(c(" ",K)[T+1],1,5^N,,"")}

ลองออนไลน์!

ใช้การเข้ารหัสเกือบเหมือนกับOuros ' ; อย่างไรก็ตามจะไม่ย้อนกลับบิตแทนที่จะเลือกที่จะใช้พวกเขาโดยตรง

จากนั้นจะสร้างเมทริกซ์ 5x5 บิตและสร้างKronecker Power matrix เพื่อสร้างรูปแบบที่จำเป็นเขียนผลลัพธ์ไปยัง stdout

สะอาด , 436 372 ไบต์

สั้นลงอย่างมากด้วยรูปแบบ IO ใหม่

import StdEnv,StdLib
t=transpose
f=flatten
$0c=[[c]]
$n c=f[t(f[t($(n-1)if(isOdd({#18415150,16301615,31491134,16303663,32554047,1096767,15262766,18415153,32641183,15254032,18128177,32539681,18405233,18667121,15255086,1097263,32294446,18136623,16267326,4329631,15255089,4539953,11191857,18157905,4329809,32575775}.[toInt(max'A'c)-65]>>p))c' ')\\p<-[i..i+4]])\\i<-[0,5..20]]

ลองออนไลน์!

บีบอัดรูปแบบตัวอักษรเป็นบิตของตัวอักษรจำนวนเต็มเพื่อประหยัด ~ 700 ไบต์ ตัวอย่างเช่นA:

1. เรียบ [[' AAA '],['A A'],['AAAAA'],['A A'],['A A']]
2. ย้อนกลับ [' AAA A AAAAAAA AA A']
3. เปลี่ยน['A AA AAAAAAA A AAA ']เป็นไบนารี ( 'A' = 1, ' ' = 0)
4. เปลี่ยน0b1000110001111111000101110เป็นทศนิยม
5. ได้รับ 18415150

R , 259 ไบต์

function(K,N,`!`=utf8ToInt){if(N)for(i in 1:N)T=T%x%(sapply(!"			




",intToBits)[1:5,5*(-64+!K)-4:0]>0)
write(c(" ",K)[T+1],1,5^N,,"")}

ลองออนไลน์!

ข้อความปฏิเสธความรับผิดชอบ:
โซลูชันนี้ได้มาจากการตอบ @ Giuseppeและแทนที่การบีบอัดเมทริกซ์ด้วยวิธีการอื่นที่คล้ายกันมากกับวิธีที่ใช้ในคำตอบของ @ Arnauldดังนั้นก่อนอื่นเลยโหวตขึ้น :)

แนวคิดมีดังต่อไปนี้:

รับ5 x 26*5เมทริกซ์นี้จาก0/1:

(1 replaced by '#', 0 replaced by '.' and '|' added for readability)

.####|#####|.###.|#####|#####|#####|.###.|#####|#...#|...#.|#####|#####|#####|
#.#..|#.#.#|#...#|#...#|#.#.#|#.#..|#...#|..#..|#...#|....#|..#..|....#|.#...|
#.#..|#.#.#|#...#|#...#|#.#.#|#.#..|#...#|..#..|#####|....#|..#..|....#|..#..|
#.#..|#.#.#|#...#|#...#|#.#.#|#.#..|#.#.#|..#..|#...#|....#|.#.#.|....#|.#...|
.####|.#.#.|#...#|.###.|#...#|#....|..##.|#####|#...#|####.|#...#|....#|#####| ...
  ^     ^     ^     ^     ^     ^     ^     ^     ^     ^     ^     ^     ^   
  |     |     |     |     |     |     |     |     |     |     |     |     |   
  A     B     C     D     E     F     G     H     I     J     K     L     M   

แต่ละคอลัมน์ถือเป็นเลขฐานสองและแปลงเป็นจำนวนเต็ม จำนวนเต็มเหล่านี้จะถูกแปลงเป็น ASCII ที่ไม่สามารถพิมพ์ได้ในช่วง 1 ... 31:

เช่นสำหรับคอลัมน์ของ"B"สตริงสุดท้ายจะเป็น"\017\021\017\021\017"(ตัวอักษรที่ไม่สามารถพิมพ์ได้ซึ่งเขียนด้วยการแสดงฐานแปด):

#####                   ####.     11110          15            '\017'
#.#.#                   #...#     10001          17            '\021'
#.#.#      ------->     ####. --> 11110  ------> 15   ------>  '\017'
#.#.#                   #...#     10001          17            '\021'
.#.#.                   ####.     11110          15            '\017'

          (transposed                  bin to int   int to ASCII
         for reability)    

ดังนั้นด้วยสตริงสุดท้ายของ5*26 = 130ตัวละครเราแปลงสตริงนั้นกลับไปเป็นเมทริกซ์ของการ0/1ใช้:

sapply(utf8ToInt(STRING),intToBits)

แล้วเราก็ subsect เมทริกซ์เลือกเพียงครั้งแรก 5 แถว (intToBits ผลตอบแทน 32 บิต) และเฉพาะคอลัมน์ที่สอดคล้องกับตัวอักษรที่ผ่านมาเป็น input และในที่สุดเราใช้ Kronecker ที่อธิบายไว้ใน@ คำตอบของจูเซปเป้