เลือกอักขระห้าตัวที่ภาษาของคุณรองรับ มี 5! = 5 × 4 × 3 × 2 × 1 = 120 วิธีการเหล่านี้สามารถจัดเป็นสตริง 5 ตัวที่มีอักขระแต่ละตัวครั้งเดียว; 120 พีชคณิต

เลือกตัวละครของคุณว่าเมื่อใดที่มีการเรียกใช้สตริง 120 ในภาษาของคุณเอาต์พุต 120 ที่สร้างขึ้นจะมีจำนวนเต็มไม่ซ้ำกันจำนวนมากตั้งแต่ 1 ถึง 120 (รวม) เท่าที่จะเป็นไปได้

นั่นคือสำหรับการเรียงสับเปลี่ยน 120 ตัวของ 5 ตัวอักษรของคุณที่สร้างรหัสที่รันได้ที่ส่งออกตัวเลขเดียวคุณต้องการให้ชุดของตัวเลขเหล่านั้นทั้งหมดจับคู่ให้ใกล้ที่สุดกับชุดของจำนวนเต็มตั้งแต่ 1 ถึง 120

ดังนั้นความนึกคิดการเปลี่ยนแปลงครั้งแรกของคุณจะส่งออก1ต่อไป2ต่อไปตลอดทางขึ้นไป3 120แต่อุดมคตินั้นเป็นไปไม่ได้สำหรับภาษาและตัวละครส่วนใหญ่

สายอักขระ 5 ตัวอาจถูกเรียกใช้เป็น:

• โปรแกรมที่ไม่มีอินพุต
• ฟังก์ชั่นที่ไม่มีข้อโต้แย้ง
• REPLคำสั่ง

สตริงที่แตกต่างกันสามารถทำงานได้หลายวิธีหากต้องการ

สำหรับเอาต์พุตที่จะนับต้องเป็นเอาต์พุตจำนวนเต็มเดียวในวิธีปกติเช่น:

• ถูกพิมพ์ไปยัง stdout
• ส่งคืนโดยฟังก์ชัน
• ผลลัพธ์ของการแสดงออก REPL

รหัสควรยุติตามปกติ (ซึ่งอาจเกี่ยวข้องกับข้อผิดพลาดตราบใดที่มีการส่งออกหมายเลขแรก) โค้ดที่ไม่ทำงานเลยก็ใช้ได้ แต่เอาท์พุท (ไม่มีอยู่) จะไม่ถูกนับ ตัวเลขที่ส่งออกควรเป็นทศนิยมเว้นแต่ฐานที่ต่างกันจะเป็นบรรทัดฐานสำหรับภาษาของคุณ

การส่งที่สร้างหมายเลขที่แตกต่างกันมากที่สุดตั้งแต่ 1 ถึง 120 ชนะ การส่งก่อนหน้านี้จะชนะในกรณีที่เสมอกัน

หมายเหตุ

• อักขระ 5 ตัวของคุณไม่จำเป็นต้องแตกต่างกัน แต่แน่นอนว่าการมีอักขระซ้ำกันจะช่วยลดจำนวนการเปลี่ยนลำดับที่มีประสิทธิภาพ
• เอาท์พุทลอยเช่นนับเช่นเดียวกับธรรมดา32.0 32(แต่32.01จะไม่)
• ชั้นนำ zeroes เช่นนับเช่นเดียวกับธรรมดา03232
• ผลลัพธ์ที่ถูกต้องควรกำหนดและไม่เปลี่ยนแปลงเวลา
• เรากำลังจัดการกับตัวละครไม่ใช่ไบต์

ตัวอย่าง

ตัวละคร123+*เป็นตัวเลือกแรกที่สมเหตุสมผลสำหรับ REPL ของ Python (หรือหลายภาษา) ผลลัพธ์ของการเปลี่ยนลำดับ 120 และผลลัพธ์คือ:

123+* n/a
123*+ n/a
12+3* n/a
12+*3 n/a
12*3+ n/a
12*+3 36
132+* n/a
132*+ n/a
13+2* n/a
13+*2 n/a
13*2+ n/a
13*+2 26
1+23* n/a
1+2*3 7
1+32* n/a
1+3*2 7
1+*23 n/a
1+*32 n/a
1*23+ n/a
1*2+3 5
1*32+ n/a
1*3+2 5
1*+23 23
1*+32 32
213+* n/a
213*+ n/a
21+3* n/a
21+*3 n/a
21*3+ n/a
21*+3 63
231+* n/a
231*+ n/a
23+1* n/a
23+*1 n/a
23*1+ n/a
23*+1 23
2+13* n/a
2+1*3 5
2+31* n/a
2+3*1 5
2+*13 n/a
2+*31 n/a
2*13+ n/a
2*1+3 5
2*31+ n/a
2*3+1 7
2*+13 26
2*+31 62
312+* n/a
312*+ n/a
31+2* n/a
31+*2 n/a
31*2+ n/a
31*+2 62
321+* n/a
321*+ n/a
32+1* n/a
32+*1 n/a
32*1+ n/a
32*+1 32
3+12* n/a
3+1*2 5
3+21* n/a
3+2*1 5
3+*12 n/a
3+*21 n/a
3*12+ n/a
3*1+2 5
3*21+ n/a
3*2+1 7
3*+12 36
3*+21 63
+123* n/a
+12*3 36
+132* n/a
+13*2 26
+1*23 23
+1*32 32
+213* n/a
+21*3 63
+231* n/a
+23*1 23
+2*13 26
+2*31 62
+312* n/a
+31*2 62
+321* n/a
+32*1 32
+3*12 36
+3*21 63
+*123 n/a
+*132 n/a
+*213 n/a
+*231 n/a
+*312 n/a
+*321 n/a
*123+ n/a
*12+3 n/a
*132+ n/a
*13+2 n/a
*1+23 n/a
*1+32 n/a
*213+ n/a
*21+3 n/a
*231+ n/a
*23+1 n/a
*2+13 n/a
*2+31 n/a
*312+ n/a
*31+2 n/a
*321+ n/a
*32+1 n/a
*3+12 n/a
*3+21 n/a
*+123 n/a
*+132 n/a
*+213 n/a
*+231 n/a
*+312 n/a
*+321 n/a

มีการสร้างตัวเลข 36 ตัวโชคดีที่ทั้งหมดภายใน 1 ถึง 120:

36, 26, 7, 7, 5, 5, 23, 32, 63, 23, 5, 5, 5, 7, 26, 62, 62, 32, 5, 5, 5, 7, 36, 63, 36, 26, 23, 32, 63, 23, 26, 62, 62, 32, 36, 63

อย่างไรก็ตามมีเพียง 8 คนเท่านั้นที่ไม่ซ้ำกัน:

36, 26, 7, 5, 23, 32, 63, 62

ดังนั้นการส่งดังกล่าวจะทำคะแนนได้ 8 จาก 120 สูงสุดเท่านั้น

Python3, 21 27 ค่า

ตัวอักษร: 3479%

หมายเลขเฉพาะ: [1,2,3,4,5,6,7,8,9,11,12,19,20,21,24,29,34,35,36,37,39,43,46,47,49,73,74]

ในขณะที่มันได้รับการร้องขอที่นี่มีการเปลี่ยนลำดับที่ลดลงในช่วง[1, 120] ลองออนไลน์!

347%9   5
349%7   6
34%79   34
34%97   34
374%9   5
379%4   3
37%49   37
37%94   37
394%7   2
397%4   1
39%47   39
39%74   39
3%479   3
3%497   3
3%749   3
3%794   3
3%947   3
3%974   3
437%9   5
439%7   5
43%79   43
43%97   43
473%9   5
479%3   2
47%39   8
47%93   47
493%7   3
497%3   2
49%37   12
49%73   49
4%379   4
4%397   4
4%739   4
4%793   4
4%937   4
4%973   4
734%9   5
739%4   3
73%49   24
73%94   73
743%9   5
749%3   2
74%39   35
74%93   74
793%4   1
794%3   2
79%34   11
79%43   36
7%349   7
7%394   7
7%439   7
7%493   7
7%934   7
7%943   7
934%7   3
937%4   1
93%47   46
93%74   19
943%7   5
947%3   2
94%37   20
94%73   21
973%4   1
974%3   2
97%34   29
97%43   11
9%347   9
9%374   9
9%437   9
9%473   9
9%734   9
9%743   9

05AB1E , 27 38 41 หมายเลข

4·>Ìn

สร้างหมายเลขเฉพาะ:

[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 25, 27, 32, 33, 34, 35, 36, 37, 38, 49, 50, 52, 54, 64, 65, 66, 67, 72, 73, 74, 81, 83, 98, 100, 101, 102]

ใช้อย่างต่อเนื่อง4กับการดำเนินงาน+1, +2, และ*2^2

Python 18 หมายเลข

237#-

สร้างผลลัพธ์ที่ถูกต้อง:

1, 2, 3, 4, 5, 7, 16, 23, 24, 25, 27, 32, 35, 37, 69, 71, 72, 73

แก้ไข:ฉันสามารถยืนยันได้ว่าโซลูชันของ TuukkaXนั้นดีที่สุดสำหรับ Python ฉันรันโค้ดต่อไปนี้เพื่อรวมชุดอักขระ ASCII ที่พิมพ์ได้ทั้งหมด 5 ตัว:

from itertools import permutations,combinations_with_replacement

def perms(chars):
  result=set()
  for permut in permutations(chars):
    try:
      current=eval(''.join(permut))
      assert str(int(current))==str(current)
      result.add(int(current))
    except:
      pass
  return sum([1 for x in result if 1<=x<=120])

best=1
for c in combinations_with_replacement(' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~',5):
    string=''.join(c)
    r=perms(string)
    if r>=best:
        best=r
        print(r,string,end='\n')

ผล (หลังจากที่ทำงานมาเกือบ 7 ชั่วโมง) แสดงให้เห็นว่าทางออกที่ดีที่สุดในความเป็นจริง 27 ตัวเลขที่แตกต่างที่ผลิตโดยสามโซลูชั่นที่แตกต่างกันทั้งหมดโดยใช้ตัวเลขสี่และ mod ( %) %3479, และ%5679%5789

หมายเลข Java 8, 2 4

n->12  // returns 12
n->21  // returns 21
n1->2  // returns 2
n2->1  // returns 1

ไม่ได้คาดหวังคำตอบ Java ใช่ไหม?

นี่คือแลมบ์ดาที่สามารถจัดเรียงได้หนึ่งในสองวิธีเท่านั้น (และด้วยตัวเลขสองหลักที่แตกต่างกัน!) สำหรับจำนวนที่ไม่ซ้ำกันสองหมายเลข ทุกอย่างไม่ใช่แลมบ์ดาที่ถูกต้อง

ปรับปรุงคำตอบจริงขอบคุณความช่วยเหลือจากความคิดเห็น! ไม่เห็นว่า 0 ไม่ถูกต้องและลืมว่าตัวแปรอาจเป็นได้มากกว่าหนึ่งตัวอักษร เรามี 4!

ทางออกที่เลวร้ายยิ่งกว่า

()->1

แต่ในแง่ที่สว่างแล้วคำตอบสองข้อที่ไม่เหมือนใครใน Java!

เยลลี่หมายเลข26 30 32

‘’3²Ḥ

นี่ (และแอนนาแกรม) เป็นโปรแกรมเต็มรูปแบบที่ไม่มีอินพุตและสร้างเอาต์พุตบนเอาต์พุตมาตรฐาน

เอาต์พุตจาก 120 โปรแกรมนั้นเป็นไปตามลำดับที่เยลลี่สร้างขึ้นหากคุณขอให้สร้างการเรียงสับเปลี่ยนของโปรแกรม:

018 036 06 03 09 03 18 116 116 117 125 135 06 03 14 15 13 22 19 13 24
28 33 42 018 036 06 03 09 03 -132 -164 -120 -119 -149 -137 26 43 18 17 
33 24 -19 13 -216 -210 53 44 18 36 30 31 49 63 18 36 10 9 25 17 18 19
18 17 18 18 36 48 36 26 36 36 06 03 14 15 13 22 06 03 -18 -17 -13 -24
06 07 06 05 06 06 03 12 03 -14 03 03 09 03 14 18 03 12 09 03 -116 -110 
23 14 09 015 09 05 09 09 03 12 03 -14 03 03

หากคุณเพิ่งจะเอาท์พุทที่ไม่ซ้ำกันในลำดับตัวเลขคุณจะได้รับ:

-216 -210 -164 -149 -137 -132 -120 -119 -116 -110 -24 -19 -18 -17 -14 -13
03 05 06 07 09 10 12 13 14 15 17 018 19 22 23 24 25 26 28 30 31 33 036 42
43 44 48 49 53 63 116 117 125 135

หลายสิ่งเหล่านี้เล็กเกินไปและ 135 ใหญ่เกินไป แต่ก็ยังมี 32 ตัวที่อยู่ในระยะ

แนวคิดพื้นฐานคือการใช้คำสั่ง monadic ส่วนใหญ่ (ในโปรแกรมที่มี monads และ nilads เพียงอย่างเดียวซึ่งแต่ละอันจะแปลงผลลัพธ์ก่อนหน้านี้) และอันที่อนุญาตให้ค่าแตกต่างอย่างรวดเร็ว ข้อยกเว้นคือด้วย3ซึ่งเป็น nilad (ค่าคงที่ 3) หากปรากฏขึ้นที่จุดเริ่มต้นของโปรแกรมการดำเนินการทั้งหมดจะทำจาก 3 หากปรากฏตรงกลางโปรแกรมจะแยกโปรแกรมออกเป็นสองครึ่งแต่ละอันจะแสดงผลเป็นจำนวนเต็ม (และแต่ละครั้งจะพิมพ์ออกเป็นเอาต์พุตมาตรฐาน ผลลัพธ์จะได้รับการต่อกันทำให้เรา "concatenate" เป็นการดำเนินการเพิ่มเติมเพื่อสร้างตัวเลข)

การดำเนินการที่เรามีที่นี่ในบริบทที่โปรแกรมสร้างขึ้นมาคือ: เพิ่มขึ้น พร่อง; คงที่ 3; ตาราง; และสองเท่า การเพิ่มและลดลงเป็นสิ่งที่ตรงกันข้ามโชคร้ายและการลดลงมีแนวโน้มที่จะสร้าง -1 หรือ -2 ในส่วนแรก (ซึ่งนำไปสู่จำนวนลบโดยรวม) แต่สิ่งนี้ยังให้ผลลัพธ์ที่แพร่กระจายมากกว่าสิ่งอื่น ๆ ที่ฉันพยายาม . โดยเฉพาะอย่างยิ่งเราได้รับการแพร่กระจายที่ดีของทั้งครึ่งแรกและครึ่งที่สองของจำนวน (โปรดทราบว่าครึ่งแรกสามารถเป็นสตริง null ถ้า3เป็นตัวอักษรตัวแรกในโปรแกรม)

จาวาสคริปต์, 27 หมายเลข

คล้ายกับคำตอบของ TuukkaXมากโดยมีตัวเลขอีกชุดหนึ่ง

5789%

ค่า 27 ที่แตกต่างคือ:

589 %   7 -> 1
987 %   5 -> 2
978 %   5 -> 3
879 %   5 -> 4
985 %   7 -> 5
958 %   7 -> 6
975 %   8 -> 7
 95 %  87 -> 8
  9 % 875 -> 9
 97 %  85 -> 12
 89 %  75 -> 14
 95 %  78 -> 17
 78 %  59 -> 19
 79 %  58 -> 21
 98 %  75 -> 23
 87 %  59 -> 28
 89 %  57 -> 32
 97 %  58 -> 39
 98 %  57 -> 41
 57 %  98 -> 57
 58 %  97 -> 58
 59 %  87 -> 59
 75 %  98 -> 75
 78 %  95 -> 78
 79 %  85 -> 79
 85 %  97 -> 85
 87 %  95 -> 87

Brachylogหมายเลข 26

3+*^-

ผลลัพธ์นี้ตัวเลขต่อไปนี้: [2,3,4,5,6,7,8,9,10,16,17,18,19,20,25,26,30,31,32,35,36,37,48,49,63,64]

คำอธิบาย

• 3 คือจำนวนเต็ม 3 อย่างชัดเจน
• + เป็นการเพิ่มขึ้น
• * เป็นสองเท่า
• ^ เป็นสี่เหลี่ยมจัตุรัส
• - คือการลดลง

มีหลายสถานการณ์ที่โปรแกรมผิดพลาดเพียงอย่างเดียวตัวอย่างเช่น*+^3-ข้อผิดพลาดเนื่องจากมันถามว่า“ เอา 0, เพิ่มขึ้นสองเท่า, ยกกำลังสอง, ผลลัพธ์ของช่องนั้นคือ 3, การลดลง”ซึ่งเห็นได้ชัดว่าผิด

โปรแกรมใด ๆ ที่ลงท้ายด้วย3จะออก3หรือไม่ทำงาน

โปรแกรมใด ๆ ที่เริ่มต้นด้วย*3จะวนซ้ำไม่สิ้นสุดเนื่องจากข้อผิดพลาด (Brachylog พยายามค้นหารายการย่อยซึ่งผลลัพธ์ของผลิตภัณฑ์ใน 3 ซึ่งเป็นไปไม่ได้)

เป็นกลุ่ม 16 หมายเลข

i1234

พิมพ์

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

รหัสเครื่อง IA-32 หมายเลข 8

ค่าไบต์เลขฐานสิบหก:

2c 40 48 b0 c3

รหัสจะถูกเรียกใช้เป็นฟังก์ชันที่คืนค่าalมา

วิธีเรียงสับเปลี่ยนที่ถูกต้อง:

b0 2c c3 xx xx => 2c (mov al, 2c)

b0 40 c3 xx xx => 40 (mov al, 40)

b0 48 c3 xx xx => 48 (mov al, 48)

b0 2c 40 c3 48 => 2d (mov al, 2c; inc eax)

b0 2c 48 c3 40 => 2b (mov al, 2c; dec eax)

b0 40 48 c3 2c => 3f (mov al, 40; dec eax)

b0 48 40 c3 2c => 49 (mov al, 48; inc eax)

b0 48 2c 40 c3 => 8 (mov al, 48; sub al, 40)

ฉันทำการค้นหาที่โหดร้ายโดยมีข้อ จำกัด ดังต่อไปนี้:

• ไบต์แรกคือb0- เพื่อเริ่มต้นการalลงทะเบียน
• ไบต์สุดท้ายคือc3- ส่งคืน; ไบต์ต่อไปนี้จะถูกยกเลิก
• ไบต์ opcode ที่เป็นไปได้คือ:
  • 0x04 - add
  • 0x0c - or
  • 0x24 - and
  • 0x2c - sub
  • 0x34 - xor
  • 0xd4 - aad
  • 0x40 - inc
  • 0x48 - dec

เหลือเพียง 3 ไบต์ที่สามารถเปลี่ยนแปลงได้ซึ่งมีผลลัพธ์ที่เป็นไปได้สูงสุด 15 รายการ ในจำนวนนี้สามารถมีได้สูงสุด 9 รายการ (อันที่จริงเกิดขึ้นกับไบต์เดียวเท่านั้น!) หนึ่งในค่าอยู่นอกช่วงดังนั้นค่านี้จึงเหลือ 8 ค่า มีชุดของไบต์อื่น

34 40 48 b0 c3

ซึ่งยังให้ค่าที่แตกต่างกัน 8 ค่า - โปรแกรมเหมือนกันยกเว้นsubแทนที่ด้วยxorซึ่งทำให้เอาต์พุตที่เป็นไปได้สองรายการเหมือนกัน

ชุดไบต์อื่น ๆ ทั้งหมดให้ผลลัพธ์ที่เป็นไปได้ 7 หรือน้อยกว่า

เยลลี่ 33 หมายเลข

Ḥ23+c

Ḥคู่ (ซ้าย)
2ตามตัวอักษร 2;
3ตามตัวอักษร 3;
+เพิ่ม (ซ้าย, ขวา); และ
cเลือก (ซ้าย, ขวา) คือจำนวนวิธีในการเลือกวัตถุที่ถูกต้องจากชุดของวัตถุด้านซ้าย

ตัวเลขให้ผลกับโปรแกรมตัวอย่าง:

 1 +32Ḥc   18 3Ḥc2+    45 2+3Ḥc
 2 c3Ḥ+2   20 2+Ḥc3    47 23c+Ḥ
 3 c2Ḥ+3   21 2Ḥ+3c    48 c+23Ḥ
 4 +2Ḥc3   22 3Ḥc+2    53 2c+Ḥ3
 5 2+3cḤ   23 23cḤ+    56 3Ḥ+2c
 6 3c+2Ḥ   24 cḤ+23    63 c+2Ḥ3
 8 2c+3Ḥ   30 3+c2Ḥ    65 32c+Ḥ
 9 3c2+Ḥ   32 32cḤ+    66 c+32Ḥ
12 +3cḤ2   33 cḤ+32    72 3c+Ḥ2
13 +2cḤ3   36 3+Ḥc2    82 c+3Ḥ2
15 +3Ḥc2   42 cḤ3+2   120 3+2Ḥc

ฉันพยายามเลือกแยกวิเคราะห์ได้ง่าย แต่บางอันหายากและแปลกแยกเล็กน้อยตัวอย่างเช่น23:

23cḤ+: (23 c (2 * 23)) + 23 = (23 c 46) + 23 = 0 + 23 = 23

... และ72และ13ใช้การพิมพ์โดยนัย:

3c+Ḥ2: z = (3 c 0) + (3 * 2); print(z); z = 2; print(z)
       z =    1    +    6   ; print(z); z = 2; print(z)

+2cḤ3: z = (0 + 2) c (2 * 0); print(z); z = 3; print(z)
       z =    2    c    0   ; print(z); z = 3; print(z)
       z =         1        ; print(z); z = 3; print(z)

โปรดทราบว่าḤ34+cยังผลิตค่าไม่ซ้ำกันใน33[1,120]

Brain-Flak 1

(())#

Brain-Flak ต้องการการจัดฟันที่สมดุลดังนั้นโปรแกรมตัวละคร 5 ตัวจะใช้ได้ต่อเมื่อตัวละครตัวหนึ่งเริ่มแสดงความคิดเห็น นั่นทำให้เรามีตัวละคร 4 ตัวที่จะทำงานด้วย ในบรรดานั้นต้องมี 2 อย่าง(และ)ไม่มีสิ่งใดที่จะถูกผลักลงบนสแต็ก ผู้ที่จะต้องไปก่อนและที่ 4 ด้วยความคิดเห็นล่าสุด ( (..)#) ตอนนี้เราสามารถใส่(), {}, <>หรือ[]ภายใน {}, <>และ[]แต่ละค่าประเมินเป็น 0 แต่()เท่ากับ 1 นั่นหมายความว่า(())#เป็นสตริงอักขระ 5 ตัวเท่านั้นที่สร้างโปรแกรม Brain-Flak ที่ถูกต้อง

ลองออนไลน์!

หากคำถามเป็น " ตัวละครที่ทรงพลังที่สุด6ตัว" คำตอบจะเป็น(){}[]เหมือน Brain-Flak ที่สมบูรณ์โดยใช้ชุดย่อยนี้เท่านั้น

Hexagony 13 หมายเลข

)24!@

ตัวเลขเหล่านี้คือตัวเลข 13 ตัวที่พิมพ์ได้พร้อมโปรแกรมที่เป็นไปได้หนึ่งรายการสำหรับแต่ละตัว

)!@24 1
2!@)4 2
2)!@4 3
4!@)2 4
4)!@2 5
)2!@4 12
)4!@2 14
24!@) 24
24)!@ 25
2)4!@ 34
42!@) 42
42)!@ 43
4)2!@ 52

โปรแกรมควรอธิบายตนเองอย่างเป็นธรรม @ยุติโปรแกรม!พิมพ์ค่าปัจจุบัน)เพิ่มขึ้น2และ4ผนวกเข้ากับค่าปัจจุบัน (โดยที่ค่าเริ่มต้นคือ0) เลย์เอาต์หกเหลี่ยมที่เกิดขึ้นจริงของซอร์สโค้ดไม่เกี่ยวข้องที่นี่โปรแกรมสามารถอ่านได้จากซ้ายไปขวา

นี้ควรจะเป็นที่ดีที่สุดแม้ว่าแทน2และ4คุณสามารถเลือกตัวเลขคู่ใด ๆxและดังกล่าวว่าy2 ≤ x ≤ y-2

วิธีแก้ปัญหาข้างต้นพบโดยกำลังดุร้าย (เกือบหมดจด) ต้องการหนึ่ง!(ไม่เช่นนั้นจะไม่พิมพ์อะไร) หนึ่ง@(มิฉะนั้นโปรแกรมจะไม่ยุติ) และเติมอักขระสามตัวที่เหลือด้วยการรวมกัน (ซ้ำ) ใด ๆ จาก ชุดอักขระต่อไปนี้:

#[]\/_|<>)!0123456789$

ฉันไม่เห็นว่าคำสั่งอื่นใดที่สามารถสร้างความหลากหลายได้มากขึ้น

Perl, 27 หมายเลข

3479%

Perl ไม่ได้มีในตัว REPL เพื่อให้คุณสามารถใช้re.plจากDevel :: REPL

ผล:

%9743 -> N/A
9%743 -> 9
97%43 -> 11
974%3 -> 2
9743% -> N/A
%7943 -> N/A
7%943 -> 7
79%43 -> 36
794%3 -> 2
7943% -> N/A
%7493 -> N/A
7%493 -> 7
74%93 -> 74
749%3 -> 2
7493% -> N/A
%7439 -> N/A
7%439 -> 7
74%39 -> 35
743%9 -> 5
7439% -> N/A
%9473 -> N/A
9%473 -> 9
94%73 -> 21
947%3 -> 2
9473% -> N/A
%4973 -> N/A
4%973 -> 4
49%73 -> 49
497%3 -> 2
4973% -> N/A
%4793 -> N/A
4%793 -> 4
47%93 -> 47
479%3 -> 2
4793% -> N/A
%4739 -> N/A
4%739 -> 4
47%39 -> 8
473%9 -> 5
4739% -> N/A
%9437 -> N/A
9%437 -> 9
94%37 -> 20
943%7 -> 5
9437% -> N/A
%4937 -> N/A
4%937 -> 4
49%37 -> 12
493%7 -> 3
4937% -> N/A
%4397 -> N/A
4%397 -> 4
43%97 -> 43
439%7 -> 5
4397% -> N/A
%4379 -> N/A
4%379 -> 4
43%79 -> 43
437%9 -> 5
4379% -> N/A
%9734 -> N/A
9%734 -> 9
97%34 -> 29
973%4 -> 1
9734% -> N/A
%7934 -> N/A
7%934 -> 7
79%34 -> 11
793%4 -> 1
7934% -> N/A
%7394 -> N/A
7%394 -> 7
73%94 -> 73
739%4 -> 3
7394% -> N/A
%7349 -> N/A
7%349 -> 7
73%49 -> 24
734%9 -> 5
7349% -> N/A
%9374 -> N/A
9%374 -> 9
93%74 -> 19
937%4 -> 1
9374% -> N/A
%3974 -> N/A
3%974 -> 3
39%74 -> 39
397%4 -> 1
3974% -> N/A
%3794 -> N/A
3%794 -> 3
37%94 -> 37
379%4 -> 3
3794% -> N/A
%3749 -> N/A
3%749 -> 3
37%49 -> 37
374%9 -> 5
3749% -> N/A
%9347 -> N/A
9%347 -> 9
93%47 -> 46
934%7 -> 3
9347% -> N/A
%3947 -> N/A
3%947 -> 3
39%47 -> 39
394%7 -> 2
3947% -> N/A
%3497 -> N/A
3%497 -> 3
34%97 -> 34
349%7 -> 6
3497% -> N/A
%3479 -> N/A
3%479 -> 3
34%79 -> 34
347%9 -> 5
3479% -> N/A

บังคับให้ใช้โปรแกรมดังต่อไปนี้:

use strict;
use warnings 'all';
use 5.010;

use Algorithm::Combinatorics qw(combinations);
use Algorithm::Permute;
use Scalar::Util::Numeric qw(isint);

my @chars = ( 0..9, qw(+ - * / . ; ' " \ @ $ # ! % ^ & ( ) { } =) );
my $iter  = combinations(\@chars, 5);
my $max   = 0;
my @best;

while (my $combo = $iter->next) {
    my $count = count_valid([@$combo]);

    if ($count > $max) {
        $max  = $count;
        @best = @$combo;
    }
}

say "$max -> @best";

sub count_valid {
    my ($chars) = @_;

    my $iter = Algorithm::Permute->new($chars);
    my %results;

    while (my @perm = $iter->next) {
        no warnings;
        my $val = eval join '', @perm;
        use warnings 'all';

        $results{$val} = 1 if isint($val) && $val > 0 && $val <= 120;
    }

    return scalar keys %results;
}

R, 15 18 หมายเลข

ไม่ใช่จำนวนมาก แต่อาจดีที่สุดที่สามารถทำได้ด้วย R ฉันค้นหาการรวมกันของตัวเลข0..9ทั้งหมดตัวดำเนินการ+ - * / ^และความคิดเห็นถ่าน#และแปดเอาต์พุตทั้งหมด 18 จำนวนเต็มเฉพาะระหว่าง 1 ถึง 120

-#146
-#157
-#237
-#238
-#256
-#267
-#278
-#378
-#467
-#568

-#146ตัวอย่างเช่นลอง นี่คือจำนวนเต็ม 18 ตัวที่เราจะได้รับ:

1#-46      = 1
6-4#1      = 2
4-1#6      = 3
4#-16      = 4
6-1#4      = 5
6#-14      = 6
14-6#      = 8
16-4#      = 12
14#-6      = 14
16#-4      = 16
41-6#      = 35
41#-6      = 41
46-1#      = 45
46#-1      = 46
61-4#      = 57
61#-4      = 61
64-1#      = 63
64#-1      = 64

หากคุณอยากรู้เกี่ยวกับรหัส (น่าเกลียด) ที่ใช้ในการทดสอบชุดค่าผสมที่เป็นไปได้ทั้งหมดนี่คือ มันส่งออกจำนวนของจำนวนเต็มที่ไม่ซ้ำกันระหว่าง 1 และ 120 สำหรับการรวมกันของตัวละครแต่ละตัวของความยาว 5 ไปยังไฟล์ที่เรียกว่า "datafile" ในไดเรกทอรีการทำงานปัจจุบัน

allchars = c("1","2","3","4","5","6","7","8","9","0","+","-","*","/","^")
apply(gtools::combinations(n=15, r=5, v=allchars, repeats.allowed=TRUE),
      1,
      function(chars) {
        x = apply(apply(e1071::permutations(length(chars)), 
                        1,
                        function(i) chars[i]
                        ),
                  2,
                  paste, collapse=""
            )
        u = unique(x)
        o = as.numeric(unlist(sapply(u, function(i) eval(try(parse(t=i),TRUE)))))

        f = factor(unique(o[o<=120 & o>=1 & o%%1==0]))
        write(paste(nlevels(f), paste(chars, collapse="")), "datafile", append=TRUE)
      }
)

ระดับแปดเสียง, 18

นี้ถูกพบโดยใช้การค้นหา Bruteforce *+-/0123456789:;<\^|~%บนสัญลักษณ์ แต่ใช้เวลาในการคำนวณนานเกินไป ...

-139%

ผลลัพธ์ที่เป็นไปได้:

1, 2, 3, 4, 6, 8, 9,13,16,19,22,31,38,39,88,91,92,93

อ็อกเทฟจำนวน 15 หมายเลข

ไม่มากที่จะคุยโม้ แต่นี่คือสิ่งที่ดีที่สุดที่ฉันจะได้รับใน Octave:

124+%

มันให้ตัวเลข:

1    2    3    4    5    6   12   14   16   21   24   25   41   42   43

ฉันได้ 16 ด้วย แต่ดูเหมือนว่ามันเหมือนกับคำตอบของ Sefa ...

1234%

1    2    3    4   12   13   14   21   23   24   31   32   34   41   42   43

PHP, 15 หมายเลข

1230\r

ใช้ความจริงที่ว่า PHP พิมพ์อะไรนอกแท็กของคำต่อคำ (โดยไม่ใช้นี้คุณสามารถทำตรง 1 หมายเลขกับสิ่งที่ต้องการ<?=1;) \rนอกจากนี้ยังใช้ตัวอักษรกลับรถที่เกิดขึ้นจริงมากกว่า

สร้าง (เรียงลำดับลบ 0s นำหน้า):

 1 1 2 2 3 3 10 10 12 12 12 12 13 13 13 13 20 20 21 21 21 21 23 23 23 23 30 30 31 31 31 31 32 32 32 32 102 102 103 103 120 120 123 123 123  123  130  130  132  132  132  132  201  201  203  203  210  210  213  213  213  213  230  230  231  231  231  231  301  301  302  302  310  310  312  312  312  312  320  320  321  321  321  321  1023  1023  1032  1032  1203  1203  1230  1230  1302  1302  1320  1320  2013  2013  2031  2031  2103  2103  2130  2130  2301  2301  2310  2310  3012  3012  3021  3021  3102  3102  3120  3120  3201  3201  3210  3210

หมายเลขที่ถูกต้องคือ:

1 2 3 10 12 13 20 21 23 30 31 32 102 103 120

Cubix , 7 หมายเลข

"2)@O

เอาท์พุตตัวเลขเหล่านี้:

")O2@ ->  1
")2O@ ->  2
"2)O@ ->  3
2"O@) -> 41
)"O@2 -> 50
2"O)@ -> 64
2")O@ -> 65

โปรแกรม Cubix ใด ๆ ที่ถูกต้องสำหรับความท้าทายนี้จะต้องมีการOส่งออกจำนวนเต็มและการ@ยกเลิกโปรแกรม (Cubix ไม่เคยได้ยินแม้แต่ "ข้อผิดพลาด") สิ่งนี้ให้เรา 3 ตัวอักษรเพื่อเล่นกับการสร้างผลผลิตมากที่สุด นอกจากนี้เนื่องจากวิธีการที่ Cubix จัดเรียงโค้ดบนคิวบ์ถ่านตัวแรกจะไร้ประโยชน์เว้นแต่ว่าอย่างใดอย่างหนึ่งจะเป็นถ่านทิศทาง

วิธีที่มีประสิทธิภาพที่สุดที่ฉันได้พบในการสร้างตัวเลขจำนวนมากคือการใช้"เพื่อผลักสตริงของอักขระรหัสไปยังสแต็ก ด้วยการจัดเรียงอย่างระมัดระวังเราสามารถใส่หลายตัวอักษรในจุดสุดท้ายและเพียงแค่ส่งรหัสถ่านของพวกเขา โดยใช้)เพื่อเพิ่มรายการด้านบนเราสามารถสร้างผลลัพธ์เพิ่มเติมจากข้อตกลงเหล่านี้หลายอย่าง

มีการใช้งานโปรแกรมพื้นฐานสองประเภทที่นี่ ประการแรกคือ:

"2)O@

ซึ่งขยายเป็น

  "
2 ) O @
  .

โปรแกรมส่งผลผลักดัน2ไปยังกองที่เพิ่มขึ้นกับ)ผลผลิตที่มีและสิ้นสุดลงด้วยO@

ประการที่สองคือ:

2")O@

ซึ่งขยายเป็น

  2
" ) O @
  .

โปรแกรมส่งผลผลักดันให้ถ่านรหัสของ), Oและ@, เพิ่มคนสุดท้ายที่มี)ผลผลิตที่มีและสิ้นสุดลงด้วยO@

> <> , 6 ตัวเลข

รับ 2 หมายเลขด้วยTeal Pelican

1ln";

ผลิตตัวเลขที่ไม่ซ้ำกัน [1, 4, 5, 49, 59, 108]

เราจำเป็นต้องnพิมพ์ตัวเลข
เราจำเป็นต้อง;ยุติ

นั่นทำให้เราเหลือเพียง 3 ตัวอักษรเท่านั้นที่จะทำงานด้วย

การผสมผสานที่แตกต่างกันของvalue& operatorร่วมกับ"การยืนยันเพื่อสร้างค่าที่ไม่ซ้ำกัน 6 ค่า แต่ฉันไม่พบสิ่งใดที่ดีไปกว่านั้น

Groovy 10 เบอร์

วิธีการแก้ปัญหา Man JVM เป็นสิ่งที่ไม่ดีสำหรับเรื่องนี้ ... ใครจะรู้?

1200+

ผลลัพธ์ใน:

[3, 10, 12, 17, 21, 30, 66, 80, 102, 120]

รออะไร? มันทำให้คุณถาม 17 ว่าอย่างไร

20+10 is 30.
0120+ is invalid.
2+001 is 3.
201+0 is 201.
2+100 is 102.
0+012 is 10.
21+00 is 21.
02+01 is 3.
0210+ is invalid.
10+20 is 30.
200+1 is 201.
0+210 is 210.
1200+ is invalid.
0201+ is invalid.
+0021 is 17.
1+002 is 3.
210+0 is 210.
100+2 is 102.
010+2 is 10.
00+12 is 12.
20+01 is 21.
01+20 is 21.
0+120 is 120.
+0120 is 80.
0+021 is 17.
+1020 is 1020.
0012+ is invalid.
02+10 is 12.
102+0 is 102.
012+0 is 10.
+2100 is 2100.
12+00 is 12.
00+21 is 21.
+2001 is 2001.
+0210 is 136.
+1200 is 1200.
1020+ is invalid.
0102+ is invalid.
2001+ is invalid.
001+2 is 3.
+0012 is 10.
2+010 is 10.
0021+ is invalid.
10+02 is 12.
2100+ is invalid.
+0201 is 129.
2010+ is invalid.
020+1 is 17.
1002+ is invalid.
+2010 is 2010.
1+020 is 17.
1+200 is 201.
01+02 is 3.
+1002 is 1002.
120+0 is 120.
0+102 is 102.
+0102 is 66.
002+1 is 3.
0+201 is 201.
021+0 is 17.

ความลับทางการค้าในจำนวนเต็ม Groovy / Java ที่นำหน้าด้วย 0 คือเลขฐานแปด รหัสที่ฉันใช้สำหรับการทดสอบคำตอบ Groovy ในกรณีที่มีคนต้องการเอาชนะฉัน:

("1200+" as List).permutations().collect{
    it.join()
}.collect {
    print "$it is "
    x=-1;
    try {
        x=Eval.me(it);
        println "$x."
    } catch(Exception e) {
        println "invalid."
    }
    x<=120?x:-1;
}.unique().sort();​

MATL, 15 หมายเลข

0123%

% เป็นตัวดำเนินการความคิดเห็นดังนั้นจึงจะ "ตัด" ในสถานที่ที่เป็นไปได้ทั้งหมดในครั้งเดียวช่วยในการสร้างชุดค่าผสมที่เป็นไปได้ทั้งหมดของตัวเลขและชุดย่อยของพวกเขา:

1
2
3
10
12
13
20
21
23
30
31
32
102
103
120

J, 16 เบอร์

1234]

ไม่มีอะไรแฟนซีทดสอบ1234กับกริยา 1 ตัวทั้งหมดที่สมเหตุสมผล ]เลือกอาร์กิวเมนต์ที่เหมาะสม

หมายเลขที่ไม่ซ้ำกันที่ผลิตคือ

0 4 3 34 43 2 24 42 23 32 234 243 324 342 423 432 1 14 41 13 31 134 143 314 341 413 431 12 21 124 142 214 241 412 421 123 132 213 231 312 321 1234 1243 1324 1342 1423 1432 2134 2143 2314 2341 2413 2431 3124 3142 3214 3241 3412 3421 4123 4132 4213 4231 4312 4321

ซึ่ง 16:

4 3 34 43 2 24 42 23 32 1 14 41 13 31 12 21

อยู่ในช่วง [1,120]

ทดสอบกับ

# (#~e.&(>:i.120)) ~. (". :: 0:)"1 (A.~ i.@!@#) '1234]'

Japt 41 หมายเลข

การทดลองและข้อผิดพลาดค่อนข้างมากดังนั้นอาจมีทางออกที่ดีกว่า ใช้จำนวนเต็ม3และ4และทางลัด Japt สำหรับ squaring เพิ่มและคูณด้วย1 2โปรแกรมทั้งหมด 120 โปรแกรมแสดงผลเป็นจำนวนเต็ม>0แต่มีเพียง 78 โปรแกรมเท่านั้นที่มี<=12041 รายการที่ไม่ซ้ำกัน

34²ÄÑ

สร้างตัวเลข:

1,3,4,5,6,7,8,9,13,14,17,20,21,26,27,29,30,31,32,33,34,35,36,37,38,39,42,43,44,45,47,56,59,68,69,72,73,86,87,92,93

ดูรายการตัวเลขหรือชุดของโปรแกรมที่ถูกต้อง

คำอธิบาย

บางสิ่งที่ควรทราบเกี่ยวกับ Japt ที่เกี่ยวข้องที่นี่คือ:

1. หากโปรแกรมไม่เริ่มต้นด้วย (ในกรณีนี้) หนึ่งในตัวเลขดังนั้นตัวแปรอินพุตแรกUซึ่งเป็นค่าเริ่มต้นจะ0ถูกแทรกโดยอัตโนมัติที่จุดเริ่มต้น
2. หากหนึ่งหรือทั้งสองของตัวเลขทันทีตามหนึ่งในทางลัดสำหรับการดำเนินการทางคณิตศาสตร์พวกเขาจะถูกผนวกเข้ากับมัน (เช่น3Ä4 = 3+14 = 17และในทำนองเดียวกัน4Ѳ = 4*2**2 = 16) และ
3. หากหนึ่งในตัวเลขนั้นตามหลังตัวอักษร²นั้น²และทุกอย่างที่อยู่ก่อนหน้านั้นก็จะถูกละเว้น

คำอธิบายสำหรับไม่กี่ของโปรแกรม (การผลิต1, 3, 37และ93ตามลำดับ):

²Ñ34Ä  :Square 0, multiply by 234 and add 1
4ÄѲ3  :Add 1 multiplied by 2 squared to 4, ignore that and return the 3
3²Ä4Ñ  :Square 3 and add 14 multiplied by 2
4Ñ3IJ  :Multiply 4 by 23 and add 1 squared

Befunge, 11 ตัวเลข

Befunge นั้นมีข้อ จำกัด เล็กน้อยเนื่องจากรองรับเฉพาะตัวเลขตัวเดียว ดังนั้นที่ดีที่สุดที่ฉันสามารถหาได้คือ 11 ตัวเลขสมมติว่าการคำนวณต้องปล่อยให้เรามีเพียงหนึ่งหมายเลขเท่านั้นในกองซ้อน

ตัวละครที่ดีที่สุด: 358*%

หมายเลขที่สร้าง: (เพียงหนึ่งตัวอย่างของแต่ละรายการ)

58*3% => 1
358*% => 3
38*5% => 4
538*% => 5
35*8% => 7
835*% => 8
385%* => 9
583%* => 10
358%* => 15
53%8* => 16
35%8* => 24

Python 16 หมายเลข

1234#

ใช้ # เพื่อแสดงความคิดเห็นตัวเลขที่ไม่จำเป็นทั้งหมด

dc, 19 หมายเลข

*3zO+

เอาต์พุตอยู่ด้านบนของสแต็กและข้อผิดพลาด (รวมถึงสแต็กอันเดอร์โฟล์) จะถูกละเว้น วิธีเรียงสับเปลี่ยนที่ถูกต้องคือ:

+O3*z:   1
+O*3z:   2
+Oz3*:   3
O*z3+:   4
O*3z+:   5
+O3z*:   6
+z3*O:  10
3*zO+:  11
3*Oz+:  12
Oz3*+:  13
O3z*+:  16
+3Oz*:  20
3Oz*+:  23
+zO3*:  30
O3*z+:  31
Oz+3*:  33
3Oz+*:  36
Oz3+*:  40
O3z+*:  50
TOTAL COUNT = 19 numbers

นี่คือโปรแกรม Python ที่ฉันใช้เพื่อแสดงผลลัพธ์เหล่านั้น:

#!/usr/bin/python

import sys
import itertools
import subprocess

if len(sys.argv[1]) != 5:
    print("Invalid input")
    sys.exit(1)

devnull = open("/dev/null", 'w');

r = dict()
for s in itertools.permutations(sys.argv[1]):
    p = "".join(s)
    try:
        e = (subprocess.check_output(['dc', '-e', p, '-e', 'p'], stderr=devnull))
        e = int(e)
        if 0 < e <= 120:
            r[e] = p
    except e:
        pass

for i in sorted(r):
    print("%5s: %3d" % (r[i], i))

print("TOTAL COUNT = %d numbers" % len(r))

สองสายอื่น ๆ ที่ให้คะแนนเดียวกันของ 19 และ32d+**4zO+

Smalltalk, 26 หมายเลข

1235r

คำอธิบาย: 12r35 เป็นเครื่องหมายสำหรับการใช้ radix 12 และเป็น 3 * 12 + 5
สิ่งนี้สามารถตรวจสอบได้ใน Squeak:

((Array streamContents: [:s |
    '1235r'  permutationsDo: [:each | 
        | eval |
        eval := [Compiler evaluate: each] ifError: [nil].
        (eval isInteger and: [eval >=1 and: [eval <= 120]]) ifTrue: [s nextPut: each copy -> eval]]])
  collect: #value as: Set) sorted

ให้:

#(1 2 3 5 28 31 33 37 38 41 42 47 55 58 63 66 67 68 71 76 82 86 105 107 108 116)

หากเราแทนที่บรรทัดสุดท้ายด้วย:

    sorted: #value ascending)

จากนั้นเราจะได้รับการแสดงออก:

'235r1' -> 1
'253r1' -> 1
'325r1' -> 1
'352r1' -> 1
'523r1' -> 1
'532r1' -> 1
'135r2' -> 2
'153r2' -> 2
'315r2' -> 2
'351r2' -> 2
'531r2' -> 2
'513r2' -> 2
'125r3' -> 3
'152r3' -> 3
'215r3' -> 3
'251r3' -> 3
'521r3' -> 3
'512r3' -> 3
'123r5' -> 5
'132r5' -> 5
'213r5' -> 5
'231r5' -> 5
'321r5' -> 5
'312r5' -> 5
'23r15' -> 28
'25r13' -> 28
'13r25' -> 31
'15r23' -> 33
'32r15' -> 37
'35r12' -> 37
'5r123' -> 38
'12r35' -> 41
'5r132' -> 42
'15r32' -> 47
'52r13' -> 55
'53r12' -> 55
'5r213' -> 58
'12r53' -> 63
'5r231' -> 66
'13r52' -> 67
'31r25' -> 67
'21r35' -> 68
'35r21' -> 71
'25r31' -> 76
'5r312' -> 82
'5r321' -> 86
'51r23' -> 105
'53r21' -> 107
'21r53' -> 108
'23r51' -> 116

ฉันต้องการที่จะโกงและกำหนดวิธีการ r ในจำนวนเต็มเป็น

Integer>>r
    ^self \\ 120 + 1

น่าเสียดายที่คอมไพเลอร์ช๊อปบน 1235r เพราะมันรับรู้จำนวนที่ไม่สมบูรณ์ด้วย radix แทนที่จะเป็นข้อความ r ที่ส่งไปที่ 1235 ...
ฉันสามารถเปลี่ยนคอมไพเลอร์ได้อย่างง่ายดายเช่นกัน แต่มันเป็นการโกงต่อรสนิยมของฉันมากเกินไป

Mathematica หมายเลข 16

;1234

ไม่น่าสนใจมาก แต่ฉันไม่สามารถหาอะไรที่ดีกว่าโดยใช้เลขคณิต สิ่งเดียวที่อาจใช้ได้คือใช้!สำหรับแฟคทอเรียลหรือแฟคทอเรียลสองเท่า แต่สิ่งนี้มีแนวโน้มที่จะสร้างตัวเลขจำนวนมากซึ่งเป็นไปไม่ได้ที่จะดุร้าย

ตัวเลข 16 ตัว (อยู่ในช่วง) ที่สามารถสร้างได้จากตัวอักษรด้านบน 5 ตัวคือ:

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

เวทมนตร์รูนจำนวน 19 ตัว

234p@

เป็นหลัก 3 ตัวอักษรตัวดำเนินการ pow และคำสั่ง "พิมพ์ทั้งกองและยุติ" 234p@พิมพ์ 812 (3 ^ 4 เชื่อมต่อกันด้วย 2) รายการการเรียงลำดับแบบเต็มหมายเหตุที่@ถูกแทนที่ด้วยak@เพื่อสร้างบรรทัดใหม่ระหว่างแต่ละผลลัพธ์และ a >ถูกเพิ่มเพื่อประกันว่าแต่ละบรรทัดดำเนินการอย่างอิสระ โปรดทราบว่าผลลัพธ์ไม่ได้อยู่ในลำดับเดียวกันกับโปรแกรมที่สร้างขึ้นมา (เนื่องจากบางโปรแกรมอาจสิ้นสุดเร็วขึ้น)

การเรียงสับเปลี่ยนจำนวนมากไม่ได้พิมพ์อะไรเลย (เช่น. @234pหรือp234@) แต่มี 19 ผลลัพธ์ในช่วงที่อนุญาต

ตัวเลขที่เป็นไปได้ (และหนึ่งโปรแกรมที่เป็นไปได้ที่ส่งผลให้มัน.บ่งบอกว่าตำแหน่งเหล่านั้นอาจเป็นหนึ่งในตัวละครที่เหลือในขณะที่มันไม่ได้ดำเนินการ):

2@...        2
3@...        3
4@...        4
23p@.        8
32p@.        9
42p@.       16
32@..       23
42@..       24
23@..       32
43@..       34
24@..       42
34@..       43
23p4@       48
32p4@       49
43p@.       64
34p@.       81
423p@       84
432p@       94

TI-BASIC 12 หมายเลข

23+4!

มีโอกาสมากที่สุดที่จะมีชุดค่าผสมที่ดีกว่า แต่ฉันไม่สามารถค้นหาได้

$24$

23+4!   -> 47
24+3!   -> 30
2+4!3   -> 74
2+3!4   -> 26
2!4+3   -> 11
2!+43   -> 45
2!+34   -> 36
2!3+4   -> 10
32+4!   -> 56
34+2!   -> 36
3+4!2   -> 51
3+2!4   -> 11
3!4+2   -> 26
3!+42   -> 48
3!+24   -> 30
3!2+4   -> 16
43+2!   -> 45
42+3!   -> 48
4+2!3   -> 10
4+3!2   -> 16
4!2+3   -> 51
4!+23   -> 47
4!+32   -> 56
4!3+2   -> 74

$12$

$10,11,16,26,30,36,45,47,48,51,56,74$