ฉันใหม่กับกีฬาของรหัสกอล์ฟ ฉันพยายามสร้างจำนวนเต็มโดยใช้จำนวนอักขระเฉพาะน้อยที่สุดใน C ++

สมมุติว่าเราได้จำนวนเต็ม 4

เราจะสร้างบันไดต่อไปนี้:

1
1 2
1 2 3
1 2 3 4

กล่าวโดยย่อโปรแกรมของฉันจะอ่านจำนวนเต็มบวกจาก stdin และพิมพ์แลดเดอร์นี้ไปยังเอาต์พุต ฉันพยายามทำด้วยจำนวนอักขระที่เป็นเอกลักษณ์น้อยที่สุดเท่าที่จะเป็นไปได้

โปรแกรมของฉันเป็นดังนี้:

#include<iostream>

int i;
int ii;
int iii;
int iiii;

main() {
    std::cin >> i;
    for(ii++; ii <= i; ii++) {
        int iii = iiii;
        for(iii++; iii <= ii; iii++) {
            std::cout << iii << " ";
        }
        std::cout << std::endl;
    }
}

ต่อไปนี้เป็นตัวตรวจสอบที่ฉันใช้ตรวจสอบจำนวนอักขระที่ไม่ซ้ำกันในโปรแกรมของฉัน:

#include <cstdio>
#include <cstring>
using namespace std;
int check[300],diffcnt=0,cnt=0,t;
char c;
double score;
int main(){

    memset(check,0,sizeof(check));
    FILE *in=fopen("ans.cpp","r");
    while(fscanf(in,"%c",&c)!=EOF){
        cnt++;
        if(!check[c]){
            check[c]=1;
            if(c=='\r'||c=='\n') continue;
            diffcnt++;
        }
    }
    if(diffcnt<25) printf("100\n");
    else if(diffcnt<30){
        printf("%.3lf\n",20.0*100.0/cnt+20.0*(29-diffcnt));
    }
    else{
        score=20.0;
        for(int x=95;x<cnt;x++) score*=0.9;
        printf("%.3lf\n",score);
    }
    printf("Unique Characters: %d\n", diffcnt);
    printf("Total Characters: %d\n", cnt);
    return 0;
}

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

ใครช่วยกรุณาแนะนำฉันเกี่ยวกับวิธีการเพิ่มประสิทธิภาพต่อไป (ในแง่ของจำนวนอักขระที่ใช้ซ้ำ) โปรดทราบว่าสามารถใช้ C ++ ได้เท่านั้น

ฉันเชื่อว่าฉันจัดการเพื่อลบอักขระ = ออกจากรหัสของคุณแม้ว่าตอนนี้จะช้าลงอย่างมาก

#include<iostream>

int i;
int ii;
int iii;
int iiii;

int main() {
    std::cin >> i;
    i++;
    for(ii++; ii < i;) {
    for(;iii>iiii;iii++);
    for(;iii<iiii;iii++);
    ii++;
        for(iii++; iii < ii; iii++) {
            std::cout << iii << " ";
        }
        std::cout << std::endl;
    }
}

มันไม่สวย แต่ด้วยการใช้จำนวนเต็มมากเกินไปในทางที่ผิดเราสามารถกลับไปที่ 0 โดยไม่ต้องใช้ =

นอกจากนี้เราต้องเปลี่ยนทหารยามเล็กน้อย น่าเสียดายเนื่องจากมีฉันไม่สามารถกำจัดอักขระบรรทัดใหม่ทั้งหมด (แม้ว่าจะใกล้เคียง) ดังนั้นอาจเป็นหนทางถัดไปในการตรวจสอบ

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

ในที่สุดฉันก็มี 24 ตัวละครที่ไม่ซ้ำกันโดยรวมคำตอบของ @ExpiredData และ @someone นอกจากนี้การใช้ชนิดข้อมูลแบบสั้นแทน int ช่วยเร่งความเร็วโปรแกรมของฉันเพราะใช้เวลาสั้นลงในการโอเวอร์โฟลว์ชนิดข้อมูลแบบสั้น

รหัสของฉันมีดังนี้

%:include<iostream>

short i;
short ii;
short iii;
short iiii;
char iiiii;

main() <%
    std::cin >> i;
    iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;
    iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;
    iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;
    iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;iiiii++;
    i++;
    for(ii++; ii < i; ii++) <%
        for(;iii;iii++);
        for(iii++; iii < ii; iii++)
            std::cout << iii << iiiii;
        std::cout << iii << std::endl;
    %>
%>

23 อักขระที่ไม่ซ้ำกันโดยใช้ Digraphs (ไม่รวม 25 รายการ) ไม่มี UB

การใช้ภาษา C ++ 11 ยัน initializer ไวยากรณ์ที่จะเริ่มต้นรายการจำนวนเต็มเป็นศูนย์ที่มีint var{};การหลีกเลี่ยงและ= 0(หรือในกรณีของคุณหลีกเลี่ยงทั่วโลกiiii) สิ่งนี้ทำให้คุณมีแหล่งที่มาของเลขศูนย์ที่ไม่ใช่ตัวแปรทั่วโลก (ซึ่งเริ่มต้นเป็นศูนย์แบบคงที่เป็นศูนย์

คอมไพเลอร์ปัจจุบันยอมรับไวยากรณ์นี้เป็นค่าเริ่มต้นโดยไม่ต้องเปิดใช้งานตัวเลือกพิเศษใด ๆ

(เคล็ดลับจำนวนเต็มวิจิตรคือความสนุกและ ok สำหรับการเล่นกอล์ฟด้วยการเพิ่มประสิทธิภาพปิดการใช้งาน แต่ลงนามล้นเป็นพฤติกรรมที่ไม่ได้กำหนดไว้ใน ISO c ++. การเปิดใช้งานการเพิ่มประสิทธิภาพจะหันลูปวิจิตรที่เป็นลูปไม่มีที่สิ้นสุดจนกว่าคุณจะรวบรวมกับ gcc / เสียงดังกราว-fwrapvที่จะให้ลงนามจำนวนเต็มล้นดี พฤติกรรมที่กำหนดไว้: การเติมเต็ม 2 อย่าง

ความจริงแล้วสนุก: ISO C ++ std::atomic<int>มีส่วนเสริม 2 อย่างที่กำหนดไว้! int32_tจำเป็นต้องเป็นส่วนเสริม 2 ของหากกำหนดไว้ทั้งหมด แต่พฤติกรรมการโอเวอร์โฟลว์ไม่ได้กำหนดดังนั้นจึงยังสามารถเป็น typedef สำหรับintหรือlongบนเครื่องใด ๆ ที่หนึ่งในประเภทนั้นคือ 32 บิตไม่มีช่องว่างภายในและส่วนประกอบ 2 ของ)

ไม่มีประโยชน์สำหรับกรณีนี้โดยเฉพาะ:

นอกจากนี้คุณยังสามารถเริ่มต้นตัวแปรใหม่เป็นสำเนาของที่มีอยู่กับการจัดฟันหรือไม่ (ที่มีการเริ่มต้นที่ไม่ว่างเปล่า) parens สำหรับการเริ่มต้นโดยตรง
int a(b)หรือint a{b}เทียบเท่าint a = b;

แต่int b();ประกาศฟังก์ชั่นแทนการเริ่มต้นตัวแปรเป็นศูนย์

นอกจากนี้คุณยังสามารถรับค่าศูนย์ด้วยint()หรือchar()เช่นการกำหนดค่าเริ่มต้นเป็นศูนย์ของวัตถุที่ไม่ระบุชื่อ

เราสามารถแทนที่การ<=เปรียบเทียบของคุณด้วยการ<เปรียบเทียบด้วยการแปลงเชิงตรรกะอย่างง่าย ๆ : ทำการเพิ่มตัวนับลูปทันทีหลังจากการเปรียบเทียบแทนที่จะเป็นที่ด้านล่างของลูป IMO นี้ง่ายกว่าทางเลือกที่ผู้คนเสนอเช่นใช้++ในส่วนแรกของ a for()เพื่อสร้าง 0 เป็น a 1

    // comments aren't intended as part of the final golfed version
    int n;
    std::cin >> n;      // end condition

    for(int r{}; r < n;) {      // r = rows from 0 .. n-1
        ++r;
        for(int i{}; i < r;) {
            ++i;
            std::cout << i << ' ';
        }
        std::cout << std::endl;
    }

เราสามารถตีกอล์ฟลงไปได้for(int r{}; r++ < n;)แต่ IMO นั้นง่ายกว่าที่มนุษย์จะอ่าน เราไม่ได้ปรับให้เหมาะสมสำหรับจำนวนไบต์ทั้งหมด

ถ้าเราใช้อยู่แล้วhเราสามารถบันทึก'หรือ"สำหรับพื้นที่

ถ้าสมมติว่าเป็นสภาพแวดล้อม ASCII หรือ UTF-8 พื้นที่จะcharมีค่า 32 เราสามารถสร้างมันในตัวแปรได้อย่างง่ายดายcout << c;

    char c{};
    c++; c++;            // c=2
    char cc(c+c+c+c);    // cc=8
    char s(cc+cc+cc+cc); // s=32 = ' ' = space in ASCII/UTF-8

และค่าอื่น ๆ สามารถสร้างขึ้นได้อย่างชัดเจนจากลำดับของ++และเพิ่มขึ้นอยู่กับบิตของการเป็นตัวแทนไบนารีของพวกเขา เปลี่ยน 0 (ไม่มีอะไร) หรือ 1 (++) เป็น LSB ได้อย่างมีประสิทธิภาพก่อนที่จะเปลี่ยนเป็นตัวแปรใหม่

รุ่นนี้ใช้hแทนหรือ'"

มันเร็วกว่าเวอร์ชันที่มีอยู่อย่างใดอย่างหนึ่ง (ไม่ต้องพึ่งพาการวนซ้ำยาว) และไม่มีพฤติกรรมที่ไม่ได้กำหนดอิสระจากพฤติกรรมที่ไม่ได้กำหนดมันรวบรวมมีคำเตือนที่ไม่มีg++ -O3 -Wall -Wextra -Wpedanticclang++และมีการ -std=c++11เป็นตัวเลือก มันถูกกฎหมายและพกพา ISO C ++ 11 :)

นอกจากนี้ยังไม่พึ่งพาตัวแปรระดับโลก และฉันทำให้คนอ่านง่ายขึ้นด้วยชื่อตัวแปรที่มีความหมาย

นับไม่ซ้ำไบต์: 25 , ไม่รวมการแสดงความคิดเห็นซึ่งผมปล้นด้วย g++ -Eและไม่รวมช่องว่างและขึ้นบรรทัดใหม่เหมือนเคาน์เตอร์ของคุณ ฉันใช้sed 's/\(.\)/\1\n/g' ladder-nocomments.cpp | sort | uniq -ic จาก Askubuntu นี้เพื่อนับการเกิดของตัวละครแต่ละตัวwcยังเพื่อนับจำนวนตัวละครที่ฉันมี

#include<iostream>

int main() {
    char c{};
    c++; c++;            // c=2
    char cc(c+c+c+c);    // cc=8
    char s(cc+cc+cc+cc); // s=32 = ' ' = space in ASCII/UTF-8

    int n;
    std::cin >> n;      // end condition

    for(int r{}; r < n;) {      // r = rows counting from 0
        ++r;
        for(int i{}; i < r;) {
            ++i;
            std::cout << i << s;
        }
        std::cout << std::endl;
    }
}

มีเพียง 2 fตัวอักษรเท่านั้นforเท่านั้น เราสามารถใช้ลูปแทนถ้าเรามีการใช้งานเป็นwhilew

เราอาจเขียนลูปเป็นภาษาแอสเซมบลี - สไตล์ของi < r || goto some_label;การเขียนการกระโดดแบบมีเงื่อนไขที่ด้านล่างของลูปหรืออะไรก็ตาม (แต่ใช้orแทน||) ไม่นั่นไม่ได้ผล gotoเป็นคำสั่งที่ชอบifและไม่สามารถเป็นส่วนประกอบย่อยของการแสดงออกอย่างที่มันสามารถทำได้ใน Perl มิฉะนั้นเราอาจจะใช้มันเพื่อลบ(และ)อักขระ

เราสามารถทางการค้าfสำหรับgกับif(stuff) goto label;แทนforและลูปทั้งสองทำงานอย่างน้อย 1 ย้ำเสมอดังนั้นเราจะต้องมีเพียงหนึ่งวงสาขาที่ด้านล่างเช่น asm ปกติdo{}whileโครงสร้างห่วง สมมติว่าผู้ใช้ป้อนจำนวนเต็ม> 0 ...

Digraphs และ Trigraphs

โชคดีที่มีการลบ Trigraphs ออกจาก ISO C ++ 17ดังนั้นเราจึงไม่จำเป็นต้องใช้??>แทน}ถ้าเรากำลังเล่นกอล์ฟที่ไม่เหมือนใครสำหรับการแก้ไข C ++ ล่าสุด

แต่ trigraphs เฉพาะ: ISO C ++ 17 ยังคงมี digraphs เช่น:>สำหรับ]และ%>}สำหรับ ดังนั้นในค่าใช้จ่าย%เราสามารถหลีกเลี่ยงทั้ง {และ}และใช้%:สำหรับ#การประหยัดสุทธิ 2 ตัวอักษรที่ไม่ซ้ำกันน้อยลง

และ C ++ มีคีย์เวิร์ดของโอเปอเรเตอร์เช่นnotสำหรับ!โอเปอเรเตอร์หรือbitorสำหรับ|โอเปอเรเตอร์ ด้วยxor_eqสำหรับ^=คุณสามารถเป็นศูนย์ตัวแปรด้วยi xor_eq iแต่ก็มีหลายตัวละครที่คุณไม่ได้ใช้

ปัจจุบันg++เพิกเฉยแล้วค่าเริ่มต้นแม้จะไม่มี-std=gnu++17; คุณต้องใช้-trigraphsเพื่อเปิดใช้งานพวกเขาหรือ-std=c++11หรือบางสิ่งบางอย่างเพื่อให้เป็นไปตามมาตรฐาน ISO ที่เข้มงวดซึ่งรวมถึงพวกเขา

23 ไบต์ที่ไม่ซ้ำกัน:

%:include<iostream>

int main() <%
    int n;
    std::cin >> n;

    for(int r<% %>; r < n;) <%
        ++r;
        for(int i<%%>; i < r;) <%
            ++i;
            std::cout << i << ' ';
        %>
        std::cout << std::endl;
    %>
%>

ลองออนไลน์!

รุ่นสุดท้ายใช้'อัญประกาศเดี่ยวแทนhหรือ"สำหรับตัวคั่นช่องว่าง ฉันไม่ต้องการขุดchar c{}สิ่งต่าง ๆ ดังนั้นฉันจึงลบมัน การพิมพ์ถ่านมีประสิทธิภาพมากกว่าการพิมพ์สตริงดังนั้นฉันจึงใช้มัน

Histogram:

$ sed 's/\(.\)/\1\n/g' ladder-nocomments.cpp | sort | uniq -ic  | tee /dev/tty | wc -l
     15         // newline
     95         // space
     11 %
      2 '
      3 (
      3 )
      4 +
      9 :
     10 ;
     14 <
      8 >
      2 a
      4 c
      6 d
      3 e
      2 f
     12 i
      2 l
      2 m
     11 n
      5 o
      7 r
      5 s
     11 t
      3 u
25   // total lines, including space and newline

ตัวคั่นช่องว่าง (ยังไม่ได้แก้)

ในคำตอบตอนนี้ลบ Johan Du Toit std::endsเสนอใช้คั่นสลับเฉพาะ นั่นคืออักขระ NUL char(0)และพิมพ์เป็นศูนย์ความกว้างบนเทอร์มินัลส่วนใหญ่ ดังนั้นการส่งออกจะมีลักษณะไม่1234 1 2 3 4หรือแย่กว่านั้นคั่นด้วยขยะในทุกสิ่งที่ไม่ได้เงียบลง'\0'หรือแย่กว่านั้นแยกออกจากขยะในสิ่งที่ไม่ได้ล่มสลายอย่างเงียบ

หากคุณสามารถใช้ตัวคั่นโดยพลการเมื่อตัวเลข0นั้นสร้างcout << some_zeroed_varได้ง่าย แต่ไม่มีใครต้องการ10203040มันยิ่งแย่กว่าไม่มีตัวคั่น

ฉันพยายามคิดวิธีการสร้างstd::stringโฮลดิ้ง" "โดยไม่ใช้charหรือตัวอักษรสตริง อาจจะต่อท้ายบางสิ่งด้วยหรือไม่ อาจจะใช้กับ digraph []เพื่อตั้งค่าไบต์แรกให้เป็นค่า32หลังจากสร้างหนึ่งที่มีความยาว 1 ผ่านหนึ่งในตัวสร้างหรือไม่

โจฮานยังแนะนำstd::iosฟังก์ชั่นสมาชิก () สมาชิกที่ส่งกลับตัวละครเติมปัจจุบัน ค่าเริ่มต้นสำหรับกระแสถูกกำหนดโดยและเป็นstd::basic_ios::init()' '

std::cout << i << std::cout.fill();แทนที่<< ' ';แต่ใช้.'แทน

ด้วย-เราสามารถใช้ตัวชี้ไปcoutและการใช้งานที่จะเรียกฟังก์ชันสมาชิก:->fill()
std::cout << (bitand std::cout)->fill()หรือไม่เราไม่ได้ใช้bทั้งคู่ดังนั้นเราอาจใช้&แทนคำศัพท์ที่เทียบเท่ากัน, bitand.

การเรียกฟังก์ชันของสมาชิกโดยไม่มี.หรือ->

ใส่ไว้ในชั้นเรียนและกำหนด operator char() { fill(); }

// not digraphed
struct ss : std::ostream {  // default = private inheritance
//      ss() { init(); }  // ostream's constructor calls this for us
        operator char() { return fill(); }
}

จากนั้นss s{}ก่อนลูปและstd::cout << i << s;ภายในลูป ที่ดีก็รวบรวมและทำงานได้อย่างถูกต้องแต่เรามีการใช้pและhสำหรับoperator char(),สำหรับผลขาดทุนสุทธิ 1. อย่างน้อยเราก็หลีกเลี่ยงbที่จะทำให้ฟังก์ชั่นสมาชิกpublicโดยใช้แทนstruct class(และเราสามารถแทนที่มรดกด้วยprotectedในกรณีที่เคยช่วย)

C ++ (gcc) x86_64 Linux เท่านั้น, 9295 8900 8712 6812 5590 ไบต์, 18 อักขระที่ไม่ซ้ำกัน

int m[]={111111111111111+1111111111111+1111111111111+1111111111111+1111111111111+1111111111111+1111111111111+111111111+111111111+1111111+111111+11111+11111+11+11+11+11+11+1+1+1,11111111111+11111111111+11111111111+1111111111+111111111+111111111+111111111+111111+1111+1111+111+111+111+111+11+11+11+11+11+11+11+11+11+1+1+1,111111111111111+111111111111111+111111111111+111111111111+1111111111+1111111+1111111+11111+11111+11111+1111+111+111+11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1,111111111111111+111111111111111+1111111111111+1111111111111+11111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+11111+1111+111+111+11+1+1+1,1111111111111+1111111111111+11111111111+11111111111+1111111111+1111111111+1111111111+111111+11111+11111+11111+11111+1111+1111+1111+1111+111+111+111+11+11+11+11+11+11,11111111111111+1111111111111+11111111111+11111111111+11111111111+1111111111+111111111+11111111+11111111+11111111+11111111+1111+1111+1111+1111+1111+1111+1111+1111+1111+111+1+1+1+1,111111111111111+1111111111111+1111111111111+1111111111111+1111111111111+11111111111+11111111111+1111111+11111+11111+1111+1111+11+11+11+11+11+11+11+1+1+1+1,111111111111+11111111111+1111111111+1111111111+1111111111+1111111111+1111111111+1111111111+11111111+11111+11111+11111+11111+11111+11111+1+1,111111111111111+11111111111111+11111111111+11111111111+1111111111+1111111+1111111+11111+111+111+111+111+111+111+111+111+11+11+1+1+1+1+1+1,11111111111+1111111111+111111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+11+1+1+1+1+1+1+1,111111111111+11111111111+11111111111+11111111+1111111+1111111+111111+111111+111111+111111+111111+111111+111111+111111+111111+11111+11111+111+111+111+111+111+111+111+1+1+1+1+1+1+1,11==1,1111111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111+1111+1111+1111+1111+1111+1111+1111+1111+111+111+111+11+11+11+1+1+1,1111111111111+111111111111+11111111111+1111111111+111111111+111111111+11111111+111111+111111+111111+11111+1111+111+111+1+1,111111111111+111111111111+11111111111+11111111111+11111111111+11111111111+111111111+111111111+11111111+111111+1111+1111+111+111+111,111111111111+11111111111+1111111111+1111111111+111111111+1111111+111+111+1+1+1+1,111111111111111+11111111111111+1111111111111+1111111111111+111111111111+1111111111+1111111111+1111111111+1111111+111111+111111+111111+11111+11111+11111+1111+1111+111+11+11+1+1+1+1,111111111111111+1111111111111+1111111111111+11111111111+1111111111+11111111+11111111+1111+1111+1111+111+111+111+111+11+11,111111111+111111111+11111111+11111111+11111111+1111111+1111111+111111+11111+1111+1111+1111+1111+111+111+11+11+11+11+11+1+1+1+1+1+1+1+1,11111111111111+111111111111+111111111111+11111111111+111111111+111111+111111+111111+1111+1111+1111+1+1+1+1+1+1+1+1,11111111111+11111111111+11111111111+11111111111+1111111111+1111111111+11111111+1111111+1111111+1111111+1111111+111111+11111+11+11+11+1+1+1+1+1+1+1+1,111111111111111+111111111111111+111111111111+1111111111+1111111111+11111111+11111111+1111111+1111111+111111+111111+11111+11111+111+11+11+1+1+1+1+1+1+1+1+1+1,11111111111111+11111111111111+111111111111+11111111111+11111111111+1111111+1111111+1111111+1111111+1111111+1111111+11+11+11+11+11+11+11+11+1,11111111111111+11111111111111+11111111111+1111111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+11111+11111+1111+1111+1111+111+111+111+111+111+111+11,111111111111111+1111111111111+111111111111+111111111111+111111111111+11111111111+1111111111+1111111111+111111111+111111+111111+111111+111111+1111+11+1+1,111111111111111+11111111111111+111111111111+111111111111+1111111111+1111111111+111111111+11111111+1111+1111+1111+111+111+111+111+111+11+11+11+11+11+11+11+11+1+1+1+1,11111111111111+11111111111111+11111111111111+11111111111+11111111111+1111111111+11111111+1111111+11111+11111+11111+1111+111+111+111+11+11+11+11+1+1+1+1+1+1,111111111111111+11111111111111+1111111111+111111111+111111111+111111111+11111111+1111111+111111+11111+1111+1111+1111+111+111+111+111+111+111+11+11+11+11+11+11+11+11+11+1+1+1+1,111111111111111+1111111111111+1111111111111+1111111111111+1111111111+111111111+111111111+111111111+11111111+1111111+11111+1111+1111+1111+111+111+111+11,1111111111111+1111111111+11111111+11111111+11111111+11111+1111+111+111+11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1,11111111111111+1111111111+1111111111+111111111+11111111+1111111+1111111+1111111+111111+11111+11111+11111+11111+11111+1111+1111+1111+111+111+11+11+11+11+11+11+11+1+1+1+1+1+1+1,11111111111111+1111111111+1111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+111111+11111+1111+1111+111+111+111+111+111+111+1+1+1+1+1+1,111111111111111+1111111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+111111+11111+11111+11111+1111+111+111+111+11+11+11+11+11,1111111111+111111111+1111111+1111111+111111+111111+11111+11111+11111+11111+11111+11111+1111+1111+1111+11+11+11+11+11+11+11+11+11+1+1+1,111111111111111+111111111111+111111111111+111111111111+11111111111+1111111111+1111111111+1111111111+11111111+11111+1111+1111+111+111+111+111+111+111+111+111+1,1111111111+111111111+111111111+11111111+1111111+1111111+1111111+111111+11111+11111+11111+11111+11111+111+111+111+11+11+11+1,11111111111111+11111111111111+1111111111+1111111111+1111111111+1111111111+11111111+11111111+11111111+11111111+1111111+1111111+111+111+111+111+11+11+11+11+11+11+11+1+1,111111111111+11111111111+1111111111+111111111+111111111+111111+111111+111111+111111+11111+11111+11+11+11+11+11+1,111111111+11111+11111+111+11+1+1+1+1+1+1+1+1+1};main(){((int(*)())m)();}

ลองออนไลน์!

สิ่งนี้อิงจากแนวคิดจากคำตอบ PPCGนี้ โปรแกรมภาษาเครื่องจะแสดงเป็นอาร์เรย์ของ 32 ints 1+11+111...บิตซึ่งแต่ละจะแสดงเป็นผลรวมของหนึ่ง แต่กลับกลายเป็นว่ามันอาจจะมีประสิทธิภาพมากขึ้นในการเข้ารหัสxเป็นเช่นนั้นy y%(1<<32)==xโปรแกรมภาษาเครื่องที่เข้ารหัสมีดังต่อไปนี้

0x0000000000000000:  55                         push    rbp
0x0000000000000001:  31 ED                      xor     ebp, ebp
0x0000000000000003:  53                         push    rbx
0x0000000000000004:  48 83 EC 18                sub     rsp, 0x18
0x0000000000000008:  48 8D 74 24 0C             lea     rsi, [rsp + 0xc]
0x000000000000000d:  31 C0                      xor     eax, eax
0x000000000000000f:  31 FF                      xor     edi, edi
0x0000000000000011:  6A 01                      push    1
0x0000000000000013:  5A                         pop     rdx
0x0000000000000014:  0F 05                      syscall 
0x0000000000000016:  89 C3                      mov     ebx, eax
0x0000000000000018:  85 C0                      test    eax, eax
0x000000000000001a:  74 0C                      je      0x28
0x000000000000001c:  6B ED 0A                   imul    ebp, ebp, 0xa
0x000000000000001f:  03 6C 24 0C                add     ebp, dword ptr [rsp + 0xc]
0x0000000000000023:  83 ED 30                   sub     ebp, 0x30
0x0000000000000026:  EB E0                      jmp     8
0x0000000000000028:  C7 44 24 0C 00 00 00 00    mov     dword ptr [rsp + 0xc], 0
0x0000000000000030:  FF C3                      inc     ebx
0x0000000000000032:  8B 44 24 0C                mov     eax, dword ptr [rsp + 0xc]
0x0000000000000036:  8D 78 01                   lea     edi, [rax + 1]
0x0000000000000039:  89 7C 24 0C                mov     dword ptr [rsp + 0xc], edi
0x000000000000003d:  E8 27 00 00 00             call    0x69
0x0000000000000042:  6A 20                      push    0x20
0x0000000000000044:  48 89 E6                   mov     rsi, rsp
0x0000000000000047:  52                         push    rdx
0x0000000000000048:  58                         pop     rax
0x0000000000000049:  50                         push    rax
0x000000000000004a:  5F                         pop     rdi
0x000000000000004b:  0F 05                      syscall 
0x000000000000004d:  5E                         pop     rsi
0x000000000000004e:  39 5C 24 0C                cmp     dword ptr [rsp + 0xc], ebx
0x0000000000000052:  7C DE                      jl      0x32
0x0000000000000054:  6A 0A                      push    0xa
0x0000000000000056:  48 89 E6                   mov     rsi, rsp
0x0000000000000059:  52                         push    rdx
0x000000000000005a:  58                         pop     rax
0x000000000000005b:  0F 05                      syscall 
0x000000000000005d:  5E                         pop     rsi
0x000000000000005e:  39 DD                      cmp     ebp, ebx
0x0000000000000060:  7F C6                      jg      0x28
0x0000000000000062:  48 83 C4 18                add     rsp, 0x18
0x0000000000000066:  5B                         pop     rbx
0x0000000000000067:  5D                         pop     rbp
0x0000000000000068:  C3                         ret     
0x0000000000000069:  85 FF                      test    edi, edi
0x000000000000006b:  74 2C                      je      0x99
0x000000000000006d:  89 F8                      mov     eax, edi
0x000000000000006f:  6A 0A                      push    0xa
0x0000000000000071:  59                         pop     rcx
0x0000000000000072:  48 83 EC 18                sub     rsp, 0x18
0x0000000000000076:  99                         cdq     
0x0000000000000077:  F7 F9                      idiv    ecx
0x0000000000000079:  89 C7                      mov     edi, eax
0x000000000000007b:  8D 42 30                   lea     eax, [rdx + 0x30]
0x000000000000007e:  89 44 24 0C                mov     dword ptr [rsp + 0xc], eax
0x0000000000000082:  E8 E2 FF FF FF             call    0x69
0x0000000000000087:  48 8D 74 24 0C             lea     rsi, [rsp + 0xc]
0x000000000000008c:  6A 01                      push    1
0x000000000000008e:  58                         pop     rax
0x000000000000008f:  50                         push    rax
0x0000000000000090:  5F                         pop     rdi
0x0000000000000091:  50                         push    rax
0x0000000000000092:  5A                         pop     rdx
0x0000000000000093:  0F 05                      syscall 
0x0000000000000095:  48 83 C4 18                add     rsp, 0x18
0x0000000000000099:  C3                         ret

... ซึ่งขึ้นอยู่กับรหัส C ต่อไปนี้

void print(int x){
  if( x ) {
    int y=x%10+'0';
    print(x/10);
    write(1,&y,1);
  }
}
void f() {
  int i=0,j=0,k;
  for( ;read(0,&k,1);i=i*10+k-'0' );
  do {
    for( j++,k=0; print( ++k ), write(1," ",1), k<j; );
    write(1,"\n",1);
  } while(j<i );
}

แก้ไข: ตอนนี้รับอินพุตจากstdinแทนที่จะเป็นargv[1]แทนขอบคุณ @ ASCII เท่านั้นและ @PeterCordes สำหรับคำแนะนำ!

Edit4: การเข้ารหัสปรับปรุงเล็กน้อยอย่างมีนัยสำคัญ

21 ตัวอักษรที่ไม่ซ้ำกัน + 1 บรรทัดใหม่ไม่สามารถเคลื่อนย้ายได้

%:include<iostream>
int(n)(int(i))<%
    if(--i)if(n(i))<%%>
    if(i)if(std::cout<<i<<std::addressof(std::cout)->fill())<%%>
%>
int(l)(int(i))<%
    if(n(-(--i)))<%%>
%>
int(m)(int(i))<%
    if(--i)if(m(i))<%%>
    if(i)if(l(-i))<%%>
    if(i)if(std::cout<<std::endl)<%%>
%>
int(c)(int(i))<%
    if(m(-(--i)))<%%>
%>
int(main)(int(i))<%
    if(std::cin>>i)<%%>
    if(c(-i))<%%>
%>

ไม่จำเป็นต้องเว้นช่องว่างยกเว้นบรรทัดใหม่บรรทัดแรก รวบรวมใน g ++ 7.3.0

ตัวอักษรที่ใช้: %:include<ostram>()f-.

การปรับปรุงคำตอบอื่น ๆ :

1. ลบเครื่องหมายอัฒภาคโดยเปลี่ยนforลูปเป็นifและเรียกซ้ำ
2. มีอักขระช่องว่างโดยอาคาstd::addressof(std::cout)->fill()std::cout.fill()

21 อักขระที่ไม่ซ้ำกัน 20 ตัวยกเว้นช่องว่าง

ช่องว่างทั้งหมดสามารถเปลี่ยนเป็นบรรทัดใหม่ได้

%:include<iostream>
%:include<list>
int n;
const int co<%%>;
const int ci<%not co%>;
const int cmu<%-ci-ci-ci-ci%>;
const char ctd<%-cmu-cmu-cmu-cmu-cmu-cmu-cmu-cmu%>;
const int cia<%-ctd-ctd-ctd-ctd-ctd-cmu%>;
const int ciu<%cia- -ci- -ci%>;

struct<%struct<%struct<%struct<%struct<%struct<%struct<%
int c<:ctd-ci:>;
%>d<:ctd:>;int c<:ctd-ci:>;%>d<:ctd:>;int c<:ctd-ci:>;
%>d<:ctd:>;int c<:ctd-ci:>;%>d<:ctd:>;int c<:ctd-ci:>;
%>d<:ctd:>;int c<:ctd-ci:>;%>d<:-cmu:>;int c<:-ci-cmu:>;
%>e<:co:><:ctd:><:ctd:><:ctd:><:ctd:><:ctd:><:ctd:>;

int i<:co:>;
auto ia<%e%>;
auto iu<%e%>;
int l<%std::cin>>n and co%>;

struct s<%
    int c<%std::cout<<i<:ciu:>- --i<:cia:><<ctd and n%>;
%>;
struct o<%
    int c<%--ia and n%>;
%>;
struct t<%
    std::list<s>c<%- --l%>;
    std::list<o>r<%-l%>;
    int m<%std::cout<<std::endl and n%>;
%>;
std::list<t>a<%n%>;
int main;

ออกด้วย segfault ตัวอักษรที่ใช้: %:include<ostram>;-h.

มันทำงานได้ในเวอร์ชั่นคอมไพเลอร์โดยเฉพาะบน Linux 64 บิต:

g++-5 (Ubuntu 5.5.0-12ubuntu1) 5.5.0 20171010

ด้วยพารามิเตอร์:

-std=c++17

ถึงอย่างนั้นฉันก็ไม่แน่ใจว่ามันจะใช้งานได้เสมอ มันอาจขึ้นอยู่กับหลาย ๆ อย่าง ciaและciuได้รับการชดเชยหน่วยความจำโดยแบ่งออกเป็น 4 ระหว่างและia iu i( intเป็น 32 บิตในรุ่นนี้) คุณอาจต้องเปลี่ยนหมายเลขให้ตรงกับออฟเซ็ตจริง ที่อยู่จะสามารถคาดเดาได้มากขึ้นถ้าพวกเขาทั้งหมดอยู่ในโครงสร้าง น่าเสียดายที่ไม่คงที่autoไม่อนุญาตให้ใช้

eเป็นอาร์เรย์ 0 องค์ประกอบของประเภทองค์ประกอบที่มีขนาด (2 ³² -1) × 2 ³²ไบต์ หากประเภทตัวชี้ที่สอดคล้องกันของeถูกลดลงครึ่งหนึ่งของตัวชี้ที่สูงขึ้นจะลดลงโดย (2 ³² -1) ซึ่งเทียบเท่ากับการเพิ่มขึ้นหนึ่ง สิ่งนี้สามารถรีเซ็ตตัวนับที่ลดค่าได้โดยไม่ต้องใช้เครื่องหมายความเท่าเทียมกัน

เวอร์ชันที่สมเหตุสมผลมากขึ้นซึ่งควรทำงานได้อย่างน่าเชื่อถือ แต่ใช้อักขระอีกหนึ่งตัว=:

%:include<iostream>
%:include<list>
int n;
int ci<%not n%>;
int cmu<%-ci-ci-ci-ci%>;
char ctd<%-cmu-cmu-cmu-cmu-cmu-cmu-cmu-cmu%>;
int i;
int l<%std::cin>>n and n-n%>;

struct s<%
    int c<%std::cout<<- --i<<ctd and n%>;
%>;
struct t<%
    std::list<s>c<%- --l%>;
    int r<%i=n-n%>;
    int m<%std::cout<<std::endl and n%>;
%>;
std::list<t>a<%n%>;
int main;

แม้สิ่งนี้จะไม่ทำงานใน g ++ รุ่นล่าสุดเพราะดูเหมือนจะไม่อนุญาตให้กำหนดmainในประเภทที่กำหนดเองอีกต่อไป

โปรแกรมทั้งสองนี้ไม่ใช้วงเล็บ แต่ดูเหมือนว่าอัฒภาคจะไม่สามารถหลีกเลี่ยงได้

22 ตัวละครที่ไม่ซ้ำกันยกเว้นช่องว่าง คั่นตัวเลขด้วยอักขระ NUL ที่แสดงอย่างถูกต้องบน Windows

%:include<iostream>
int main(int n)<%
    std::cin>>n;
    for(int r<%%>;r++<n;)<%
        for(int i<%%>;i<r;)
            std::cout<<++i<<std::ends;
        std::cout<<std::endl;
    %>
%>

ลองออนไลน์

Histogram:

[%] 0x25 = 9
[:] 0x3A = 11
[)] 0x29 = 3
[i] 0x69 = 11
[n] 0x6E = 12
[c] 0x63 = 4
[l] 0x6C = 2
[u] 0x75 = 3
[d] 0x64 = 8
[e] 0x65 = 4
[<] 0x3C = 13
[o] 0x6F = 5
[s] 0x73 = 7
[t] 0x74 = 12
[r] 0x72 = 6
[a] 0x61 = 2
[m] 0x6D = 2
[>] 0x3E = 7
[(] 0x28 = 3
[;] 0x3B = 7
[f] 0x66 = 2
[+] 0x2B = 4
Unique Characters: 22
Total Characters: 189