ভার্চুয়াল কীবোর্ড পাঠ্য ইনপুট

22

আধুনিক গেম কনসোলগুলি এবং traditionalতিহ্যবাহী কীবোর্ডবিহীন অন্যান্য ডিভাইসে, পাঠ্যের ইনপুট দেওয়ার চেষ্টা করা দুঃস্বপ্ন। ভার্চুয়াল কীবোর্ডে কয়েকটি বোতাম এবং জয়স্টিক দিয়ে টাইপ করা বিরক্তিকর এবং আমি যতটা সম্ভব আন্দোলন / বোতাম টিপতে চাই।

আপনি যে কীবোর্ডটি ব্যবহার করবেন তা দেখতে এমন দেখাচ্ছে:

+---+---+---+---+---+---+---+---+---+---+
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 |
+---+---+---+---+---+---+---+---+---+---+
| q | w | e | r | t | y | u | i | o | p |
+---+---+---+---+---+---+---+---+---+---+
| a | s | d | f | g | h | j | k | l | - |
+---+---+---+---+---+---+---+---+---+---+
| z | x | c | v | b | n | m | _ | @ | . |
+---+---+---+---+---+---+---+---+---+---+

নিম্নলিখিত ক্রিয়াকলাপগুলি ব্যবহার করা যেতে পারে:

  • L: কীবোর্ডের বাম দিকে একটি বর্গ সরান (মোড়ানো)
  • R: কীবোর্ডের ডানদিকে একটি বর্গ সরান (মোড়ক)
  • U: কীবোর্ডে একটি স্কোয়ার উপরে সরান (মোড়ক)
  • D: কীবোর্ডের এক বর্গাকার নীচে সরান (মোড়ানো)
  • Y: একটি স্থান .োকান
  • B: সন্নিবেশ পয়েন্টারটি একটি স্থান বাম দিকে সরান (পয়েন্টার শুরুতে থাকলে কিছুই করে না)
  • F: সন্নিবেশ পয়েন্টারটি একটি স্থান ডান দিকে সরান (পয়েন্টার শেষে থাকলে কিছুই করে না)
  • C: ক্যাপস লক টগল করুন
  • A: সন্নিবেশ পয়েন্টারের অবস্থানে নির্বাচিত অক্ষরটি সন্নিবেশ করান

উপরের কীবোর্ড এবং কমান্ডগুলি (মিলগুলি [a-zA-Z0-9 _@.-]*) ব্যবহার করে টাইপ করা যেতে পারে এমন একটি ইনপুট স্ট্রিং দেওয়া হয়েছে, আউটপুট স্ট্রিংয়ের ফলস্বরূপ কমান্ডগুলির একটি ক্রম আউটপুট দেয়। কার্সারের প্রাথমিক অবস্থান 1কী (শীর্ষ-বাম) এ রয়েছে এবং প্রাথমিকভাবে ক্যাপস লক বন্ধ রয়েছে।

স্কোরিং

যে কোনও স্ট্রিংয়ের জন্য, একটি নির্দোষ পন্থা হ'ল স্ট্রিংয়ের প্রতিটি চরিত্রের জন্য, কীবোর্ডের স্বল্পতম পাথরে অক্ষরে নেভিগেট করতে, প্রয়োজনে ক্যাপস লক টগল করুন এবং অক্ষরটি নির্বাচন করুন। এই জাতীয় নিষ্প্রভ পদ্ধতি দৈর্ঘ্যের একটি আদেশ জেনারেট করে (length of input string) + (sum of Manhattan distances on keyboard between consecutive non-space characters) + (number of times the string alternates between lowercase and uppercase characters) + (1 if string starts with an uppercase letter else 0)। উদাহরণস্বরূপ, এর জন্য নির্লজ্জ পদ্ধতির 101ফলস্বরূপ ALARA, একটি দৈর্ঘ্য 5 কমান্ড এবং Noob 5ফলস্বরূপ DDDRRRRRCAUURRRCAADDLLLLAYUUUA, একটি দৈর্ঘ্য 30 কমান্ড আসবে।

আপনার জমাটি যাইহোক, নিষ্পাপ পদ্ধতির চেয়ে ভাল করার চেষ্টা করে। প্রতিটি ইনপুট স্ট্রিংয়ের জন্য, আপনার জমাটি কমান্ডের সংখ্যার সমান পয়েন্ট পাবেন নিখুঁত দৃষ্টিভঙ্গি আপনার জমা দেওয়ার আউটপুটগুলিকে বিয়োগের সংখ্যার কম ব্যবহার করে। আপনার সামগ্রিক স্কোরটি পৃথক স্কোরগুলির সমষ্টি হবে।

বিধি

  • জমাগুলি একটি ক্লাউড 9 ফ্রি ভার্চুয়াল ওয়ার্কস্পেসে পরিচালিত হবে । ওয়ার্কস্পেসে 512 এমবি র‌্যাম, 2 গিগাবাইট ডিস্ক স্পেস, 8 ইন্টেল (আর) জিওন (আর) সিপিইউস @ 2.50 গিগাহার্জ (সম্পূর্ণ সিপিইউ তথ্য, দৌড়তে পাওয়া cat /proc/cpuinfoযায়, এখানে পাওয়া যাবে ), এবং 64-বিট উবুন্টু 14.04 চলছে is বিশ্বাসভাজন। আপনার জমাটি চালানোর জন্য এবং স্কোর করার জন্য আপনি পরীক্ষার কর্মক্ষেত্রে অ্যাক্সেসের অনুরোধ করতে পারেন বা আমি এটি আপনার জন্য স্কোর করতে পারি।
  • পরীক্ষার ক্ষেত্রে প্রতিবেদন জমা দেওয়া হবে। রানের মধ্যে স্টেট স্টোর করা নিষিদ্ধ। প্রয়োজনীয়তাগুলি ইনপুট ফাইলটি পড়ার সম্ভাব্য ব্যতিক্রম সহ উত্স ফাইল (যা রানের মধ্যে সংশোধন করা যায় না) ব্যতীত অন্য কোনও ফাইল থেকে লিখতে বা পড়তে পারে না missions
  • প্রতিটি পরীক্ষার ক্ষেত্রে সাবমিশন রানটাইমের 1 মিনিটের মধ্যে সীমাবদ্ধ। জমাগুলি একাধিক সমাধান আউটপুট করতে পারে তবে বরাদ্দ সময়ের মধ্যে কেবলমাত্র শেষ বৈধ সমাধানটি স্কোরিংয়ের জন্য ব্যবহৃত হবে। নির্ধারিত সময়ের মধ্যে কোনও বৈধ সমাধান আউটপুট ব্যর্থতার ফলে সেই পরীক্ষার ক্ষেত্রে 0 এর স্কোর দেখাবে।
  • দয়া করে আপনার জমা দেওয়ার অনুরোধ সম্পর্কিত দিকনির্দেশগুলি পাশাপাশি এমন কোনও সরঞ্জাম / লাইব্রেরি অন্তর্ভুক্ত করুন যা স্ট্যান্ডার্ড উবুন্টু 14.04 ইনস্টলের সাথে অন্তর্ভুক্ত নয় installed
  • বিজয়ী সবচেয়ে বড় স্কোর সহ জমা দেওয়া হবে। টাই হওয়ার ক্ষেত্রে আরও ভাল অ্যালগরিদমিক জটিলতার সাথে জমাটি জিতবে। টাইটি এখনও সমাধান না হলে স্কোর এবং অ্যালগরিদমিক জটিলতায় পৌঁছানোর প্রথম জমাটি জিতবে।
  • জমা পরীক্ষার ক্ষেত্রে উপযুক্ত হতে পারে না। আমি যদি প্রয়োজন অনুভব করি তবে পরীক্ষার কেসগুলি পরিবর্তন করার অধিকার আমি সংরক্ষণ করি।

পরীক্ষার মামলা

বিন্যাস: input string => naive score

(আপনি যদি এগুলিতে কোনও ত্রুটি দেখতে পান তবে সংশোধন করে একটি মন্তব্য দিন)

101 => 5
quip => 12
PPCG => 15
Mego => 25
Noob 5 => 26
penguin => 27
867-5309 => 32
2_sPoOkY_4_mE => 60
The Nineteenth Byte => 76
penguins@SouthPole.org => 95
8xM3R__5ltZgrkJ.-W b => 98
correcthorsebatterystaple => 104
verylongRUNSOFCAPSandnocaps => 118
This is an English sentence. => 122
WNtza.akjzSP2GI0V9X .0epmUQ-mo => 131
Programming Puzzles and Code Golf => 140
string  code-challenge  keyboard 
— ঐ মেগো
সূত্র
5
আমি -27 পেয়েছি ... কিছু মনে করবেন না
— লিকি নুন
1
@ মেগো: আমি মনে করি তিনি বলছেন যে তার সমাধানটি নিষ্পাপের চেয়েও খারাপ করেছে । : পি
— এল'েন্ডিয়া স্টারম্যান
2
আমি সম্মত, গেমিং কনসোল কীবোর্ড স্তন্যপান ।
— আর
প্রোগ্রামটি যদি এক মিনিটের মধ্যে শেষ না হয়ে তবে সেই সময়ের মধ্যে এক বা একাধিক সমাধান মুদ্রণ করে তবে কী হবে? অবসান না করার জন্য কি কোনও জরিমানা আছে?
— mIllIbyte
@mIllIbyte শেষ বৈধ (অর্থাত্ সঠিক পাঠ্যের ফলাফল) সময় সীমাতে প্রিন্ট করা কমান্ডটি ব্যবহৃত হয়। যদি কোনও বৈধ কমান্ড মুদ্রিত না হয় তবে স্কোর 0 হয়
— মেগো

উত্তর:

2

সি

স্কোর 193।

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define LEFT 'L'
#define RIGHT 'R'
#define CAPS 'C'
#define UP 'U'
#define DOWN 'D'
#define SPACE 'Y'
#define CURSORLEFT 'B'
#define CURSORRIGHT 'F'
#define APPLY 'A'
#define TABLEX 10
#define TABLEY 4
#define casediff(A,B) (isupper(A)*islower(B)+islower(A)*isupper(B))
typedef struct {int x; int y;} coord;
coord letters[300];
#define initLetter(letter, X, Y) \
letters[letter].x=X, letters[letter].y=Y
#define initAllLetters(); \
initLetter('1',0,0);\
initLetter('1',0,0);\
initLetter('2',1,0);\
initLetter('2',1,0);\
initLetter('3',2,0);\
initLetter('3',2,0);\
initLetter('4',3,0);\
initLetter('4',3,0);\
initLetter('5',4,0);\
initLetter('5',4,0);\
initLetter('6',5,0);\
initLetter('6',5,0);\
initLetter('7',6,0);\
initLetter('7',6,0);\
initLetter('8',7,0);\
initLetter('8',7,0);\
initLetter('9',8,0);\
initLetter('9',8,0);\
initLetter('0',9,0);\
initLetter('0',9,0);\
initLetter('Q',0,1);\
initLetter('q',0,1);\
initLetter('W',1,1);\
initLetter('w',1,1);\
initLetter('E',2,1);\
initLetter('e',2,1);\
initLetter('R',3,1);\
initLetter('r',3,1);\
initLetter('T',4,1);\
initLetter('t',4,1);\
initLetter('Y',5,1);\
initLetter('y',5,1);\
initLetter('U',6,1);\
initLetter('u',6,1);\
initLetter('I',7,1);\
initLetter('i',7,1);\
initLetter('O',8,1);\
initLetter('o',8,1);\
initLetter('P',9,1);\
initLetter('p',9,1);\
initLetter('A',0,2);\
initLetter('a',0,2);\
initLetter('S',1,2);\
initLetter('s',1,2);\
initLetter('D',2,2);\
initLetter('d',2,2);\
initLetter('F',3,2);\
initLetter('f',3,2);\
initLetter('G',4,2);\
initLetter('g',4,2);\
initLetter('H',5,2);\
initLetter('h',5,2);\
initLetter('J',6,2);\
initLetter('j',6,2);\
initLetter('K',7,2);\
initLetter('k',7,2);\
initLetter('L',8,2);\
initLetter('l',8,2);\
initLetter('-',9,2);\
initLetter('-',9,2);\
initLetter('Z',0,3);\
initLetter('z',0,3);\
initLetter('X',1,3);\
initLetter('x',1,3);\
initLetter('C',2,3);\
initLetter('c',2,3);\
initLetter('V',3,3);\
initLetter('v',3,3);\
initLetter('B',4,3);\
initLetter('b',4,3);\
initLetter('N',5,3);\
initLetter('n',5,3);\
initLetter('M',6,3);\
initLetter('m',6,3);\
initLetter('_',7,3);\
initLetter('_',7,3);\
initLetter('@',8,3);\
initLetter('@',8,3);\
initLetter('.',9,3);\
initLetter('.',9,3);
typedef struct {int length; char instr[300];} movement;
movecasefold(char*instr,coord A, coord B){
    register int i=0;int j;
    if(A.x<B.x)
     if(B.x-A.x<=TABLEX/2)
      for(;B.x-A.x!=i;)instr[i++]=RIGHT;
     else
      for(;TABLEX-B.x+A.x!=i;)instr[i++]=LEFT;
    else if(A.x>B.x)
     if(A.x-B.x<=TABLEX/2)
      for(;A.x-B.x!=i;)instr[i++]=LEFT;
     else
      for(;TABLEX-A.x+B.x!=i;)instr[i++]=RIGHT;
    j=i;
    if(A.y<B.y)
     if(B.y-A.y<=TABLEY/2)
      for(;B.y-A.y!=i-j;)instr[i++]=DOWN;
     else
      for(;TABLEY-B.y+A.y!=i-j;)instr[i++]=UP;
    else if(A.y>B.y)
     if(A.y-B.y<=TABLEY/2)
      for(;A.y-B.y!=i-j;)instr[i++]=UP;
     else
      for(;TABLEY-A.y+B.y!=i-j;)instr[i++]=DOWN;
    instr[i]='\0';
    return i;
}
char sentence[50], oldcase, oldletter;
int sentencelength;
typedef struct {
int sentencetoorder[50];
int ordertosentence[50];
int length;
} order;
ordercopy(order*a, order b){
register int i;
for(i=0;++i<sentencelength;) a->sentencetoorder[i]=b.sentencetoorder[i], a->ordertosentence[i]=b.ordertosentence[i];
a->length=b.length;
}
order currentOrder;
movetwo(char*instr,int A, int B){
    register int j; int i=0;
    if(A<B)
    { for(j=A+1;j<B;j++)
      if(currentOrder.sentencetoorder[j]<currentOrder.sentencetoorder[B])
       instr[i++]=CURSORRIGHT;
    }
    else
    { for(j=A;j>B;j--)
      if(currentOrder.sentencetoorder[j]<currentOrder.sentencetoorder[B])
       instr[i++]=CURSORLEFT;
    }
    if(sentence[B]==' '){
        instr[i++]=SPACE;
        instr[i]='\0';
        return i;
    }
    i+=movecasefold(instr+i,letters[oldletter],letters[sentence[B]]);
    oldletter=sentence[B];
    if(casediff(oldcase,sentence[B]))oldcase=sentence[B],instr[i++]=CAPS;
    instr[i++]=APPLY;
    instr[i]='\0';
    return i;
}
moveall(char*instr){
    int j;int i = 0;
    oldcase='a';
    oldletter='1';
    for(j=0;++j<sentencelength;)
        i+=movetwo(instr+i,currentOrder.ordertosentence[j-1],currentOrder.ordertosentence[j]);
    return i;
}
iteration();
main(){
initAllLetters();
gets(sentence+1);*sentence='1';sentencelength=strlen(sentence);
int i;
for(i=0;++i<sentencelength;)currentOrder.sentencetoorder[i]=currentOrder.ordertosentence[i]=i;  
char instr[300];
currentOrder.length=moveall(instr);
puts(instr);
while(iteration());
}
#define inside(item, start, stop) (((start)<=(item))&((item)<(stop)))
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
iteration(){
char instr[300];
register int i;
int newstart, start, l;
static order oldorder, neworder;
ordercopy(&oldorder,currentOrder);
ordercopy(&neworder,currentOrder);
for(l=0;++l<sentencelength-1;)
for(start=0;++start<sentencelength-l;)
for(newstart=0;++newstart<sentencelength-l;)
if(start!=newstart){
 for(i=0;++i<sentencelength;)
  if(inside(i,start,start+l))currentOrder.ordertosentence[i-start+newstart]=oldorder.ordertosentence[i];
  else if(inside(i,min(start,newstart),max(start+l,newstart+l)))currentOrder.ordertosentence[newstart<start?i+l:(i-l)]=oldorder.ordertosentence[i];
  else currentOrder.ordertosentence[i]=oldorder.ordertosentence[i];
 for(i=0;++i<sentencelength;) currentOrder.sentencetoorder[currentOrder.ordertosentence[i]]=i;
  currentOrder.length=moveall(instr);
 if(currentOrder.length<neworder.length){
  puts(instr);
  ordercopy(&neworder, currentOrder);
 }
}
ordercopy(&currentOrder, neworder);
return neworder.length<oldorder.length;
}

"জিসিসি ভার্চুয়ালকিবোর্ড.সি." হিসাবে সংকলন করুন। "./A.out" আর্গুমেন্ট ছাড়াই এটি চালান। এটি স্টিডিনের কাছ থেকে ইনপুটটি পড়ে এবং আউটপুটটি স্টডআউটে লেখে।

— mIllIbyte
সূত্র
বিলম্বের জন্য দুঃখিত - আপনার স্কোর 193
— মেগো
1

C99

সমাধানে আমার চেষ্টা এখানে। 62 স্কোর পেয়েছেন।

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#define COORDINATES_ARRAY_SIZE 256
#define MOVEMENT_ARRAY_LEN 1024

#define KEYBOARD_WIDTH 10
#define KEYBOARD_HEIGHT 4

#define DIRECTION_BIT 0x40

#define INITIAL_CHAR '1'

#define SPACE_WEIGHT_INCREMENT 2
#define SPACE_WEIGHT_MAX 10
#define CURSOR_WEIGHT_INCREMENT 2
#define CURSOR_WEIGHT_MAX 10

const char keyboard[KEYBOARD_HEIGHT][KEYBOARD_WIDTH] = {
    {'1','2','3','4','5','6','7','8','9','0'},
    {'q','w','e','r','t','y','u','i','o','p'},
    {'a','s','d','f','g','h','j','k','l','-'},
    {'z','x','c','v','b','n','m','_','@','.'}
};

typedef enum {
    right,
    left,
    up,
    down
} dir;

//iirc it is an omptimization to use int over byte or short despite only using values <10
typedef struct {
    int x;
    int y;
} coordinates;

typedef struct {
    int xmove;
    int ymove;
    dir xdir;
    dir ydir;
} movedata;

void generateCoords(coordinates*);
unsigned int nearestNeighbor(coordinates*, char*, char*, char*, char*, int, int, int, int, int, int, int);
int calcDistance(coordinates*, char, char, movedata*);

int main(int argc, char **argv){
    coordinates coords[COORDINATES_ARRAY_SIZE];
    char moves[MOVEMENT_ARRAY_LEN];
    unsigned int temp, min = 0;
    min--; //largest possible int

    if(argc != 2){
        printf("Invalid Arguments. Usage: virtualKeyboard <string>\n");

    }else{
        int len = strlen(argv[1]);
        int moveCursor, capsLock;
        char *workingString =  malloc(len * sizeof(char));
        generateCoords(coords);
        movedata data;
        for(int spaceWeight = 1; spaceWeight < SPACE_WEIGHT_MAX; spaceWeight += SPACE_WEIGHT_INCREMENT){
            for(int cursorWeight = 1; cursorWeight < CURSOR_WEIGHT_MAX; cursorWeight+= CURSOR_WEIGHT_INCREMENT){
                for(int i = 0; i<len; i++){
                    //zero out arrays
                    moveCursor = 0;
                    capsLock = 0;
                    memset(moves, 0, MOVEMENT_ARRAY_LEN);
                    memset(workingString, 0, len);
                    workingString[0] = argv[1][i];
                    //add initial moves
                    temp = calcDistance(coords, INITIAL_CHAR, argv[1][i], &data);

                    for(int j = 0; j < data.xmove; j++){
                        moves[moveCursor] = data.xdir == right ? 'R' : 'L';
                        moveCursor++;
                    }
                    for(int j = 0; j < data.ymove; j++){
                        moves[moveCursor] = data.ydir == up ? 'U' : 'D';
                        moveCursor++;
                    }
                    if((capsLock==0) != (isupper(argv[1][i])==0)){
                        moves[moveCursor] = 'C';
                        capsLock = capsLock == 0 ? 1 : 0;
                        moveCursor++;
                        temp++;
                    }
                    moves[moveCursor] = 'A';
                    temp++;
                    temp += nearestNeighbor(coords, moves, argv[1], argv[1], workingString, i ,len, len, 1, capsLock, cursorWeight, spaceWeight);
                    if(temp < min){
                        printf("%s\t%s\t%i\n", moves, workingString, temp);
                        min = temp;
                    }

                }
            }
        }
        free(workingString);
    }
    return 0;
}

//optimization so it only searches through the matrix once
void generateCoords(coordinates* coords){
    for(int i = 0; i < KEYBOARD_HEIGHT; i++){
        for(int j = 0; j < KEYBOARD_WIDTH; j++){
            coords[(int)keyboard[i][j]].y = i;
            coords[(int)keyboard[i][j]].x = j;
        }
    }
}

int calcCursorMoves(char* og, char* workingString, char added, int cursor, int len){
    char* inUseWS = calloc(len, sizeof(char));
    char* inUseOG = calloc(len, sizeof(char));
    int indexToAdd = 0, newCursor = cursor;
    for(int i = 0; i < len; i++){
        for(int j = 0; j < len; j++){
            if(workingString[j] != -1 && og[i] == workingString[j] 
                    && inUseOG[i] == 0 && inUseWS[j] == 0){
                inUseOG[i] = 1;
                inUseWS[j] = i+1; // set in use to corresponding working string
                break;
            }
            if(workingString[j] == 0){
                inUseWS[j] = -1; //append -1 to end
                break; //nothing more to see here   
            }
        }
    }
    for(int i = 0; i < len; i++){
        if(og[i] == added && inUseOG[i] == 0){
            indexToAdd = i;
            break;
        }
    }
    for(int i = 0; i < len; i++){
        if(i==0 && indexToAdd < inUseWS[i]-1){
            newCursor = i;
            break;

        }
        if(inUseWS[i]-1 < indexToAdd && (indexToAdd < inUseWS[i+1]-1 || inUseWS[i+1] == -1)){
            newCursor = i+1;
            break;
        }
        if(workingString[i+1] == 0){
            newCursor = i+1;
            break;
        }

    }
    free(inUseWS);
    free(inUseOG);
    return newCursor - cursor;  
}

int calcDistance(coordinates* coords, char from, char to, movedata* data){
    if(to == ' ')
        return 0;
    from = tolower(from);
    to = tolower(to);
    data->xmove = coords[(int)from].x - coords[(int)to].x;
    data->ymove = coords[(int)from].y - coords[(int)to].y;  
    data->xdir = data->xmove >= 0 ? left : right;
    data->ydir = data->ymove >= 0 ? up : down;
    data->xmove = abs(data->xmove);
    data->ymove = abs(data->ymove);
    //wraparound
    if(data->xmove > 5){
        data->xmove = 10 - data->xmove;
        data->xdir = data->xdir == right ? left : right;
    }   
    if(data->ymove > 2){
        data->ymove = 4 - data->ymove;
        data->ydir = data->ydir == up ? down : up;
    }
    return data->xmove + data->ymove;
}

//assumes array is longer than current string
void insertAt(char* str, char toIns, int index){
    char* temp = malloc(strlen(str) + 1);
    strncpy(temp, str, index);
    temp[index] = toIns;
    strcpy(temp+index+1, str+index);
    strcpy(str, temp);  
    free(temp);
}

unsigned int nearestNeighbor(coordinates* coords, char* moves, char* og, 
        char* input, char* workingString, int index, int lenOG, int len,  
        int cursor, int capsLock, int cursorWeight, int spaceWeight){
    if(len  == 1){
        return 0;
    }
    movedata data, bestData;
    char bestChar = '\0';
    unsigned int bestCursor = -1, bestIndex = -1, bestDist = -1;
    unsigned int dist = -1, cursorDist = -1, best = -1;
    char newString[len-1] ;
    memset(newString, 0, len-1);
    strncpy(newString, input, index);
    strcpy(newString+index, input+index+1);
//  printf("%s\t", newString);
    for(int i = 0; i < len-1; i++){
        dist = calcDistance(coords, input[index], newString[i], &data);
        cursorDist = calcCursorMoves(og, workingString, newString[i], cursor, lenOG);
        if(dist + cursorWeight * abs(cursorDist) + spaceWeight * (newString[i] == ' ') + ((capsLock==0) != (isupper(newString[i])==0)) < best){
    //      printf("%c %c %i %i\n", workingString[cursor], newString[i], cursorDist, cursor);
            bestDist = cursorDist;
            bestCursor = cursor + cursorDist;
            best = dist + cursorWeight * abs(cursorDist) + spaceWeight * (newString[i] == ' ') + ((capsLock==0) != (isupper(newString[i])==0));
            bestChar = newString[i];
            bestIndex = i;
            memcpy(&bestData, &data, sizeof(data));
        }
    }
    //append moves
    int i;
    for(i = 0; i < MOVEMENT_ARRAY_LEN && moves[i]!=0; i++);
    if(bestChar != ' '){
        for(int j = 0; j < bestData.xmove; j++){
            moves[i] = bestData.xdir == right ? 'R' : 'L';
            i++;
        }
        for(int j = 0; j < bestData.ymove; j++){
            moves[i] = bestData.ydir == up ? 'U' : 'D';
            i++;
        }
        for(int j = 0; j < abs(bestDist); j++){
            moves[i] = bestDist > 0 ? 'B' : 'F'; 
            i++;
        }
        if((capsLock==0) != (isupper(bestChar)==0)){
            moves[i] = 'C';
            capsLock = capsLock == 0 ? 1 : 0;
            i++;
        }
        moves[i] = 'A';
    } else {
        moves[i] = 'Y';
    }
    //remove weight
    best -= cursorWeight * abs(bestDist);
    best -= spaceWeight * (bestChar==' ');
    insertAt(workingString, bestChar, bestCursor);
    int max = nearestNeighbor(coords, moves, og, newString, workingString, 
             bestIndex, lenOG, len-1, bestCursor+1, capsLock, cursorWeight, spaceWeight);
    //the 1 is for the actual click
    return max + best + 1 + abs(bestDist);
}

ছোট শব্দগুলির জন্য সঠিকভাবে কাজ করা বলে মনে হয়েছিল এবং আমি কেবল ধরে নিয়েছি যে বড়রা সঠিকভাবে কাজ করবে কারণ সেগুলি আমার পক্ষে ম্যানুয়ালি পরীক্ষার জন্য খুব বড়।

"Gcc -std = gnu99" দিয়ে কম্পাইল করুন
ব্যবহার "ভার্চুয়ালকিবোর্ড" স্ট্রিং ""

— dj0wns
সূত্র
1
এটি অনেকগুলি ইনপুটগুলিতে বৈধ কমান্ড সিকোয়েন্স তৈরি করতে ব্যর্থ। উদাহরণস্বরূপ, এর জন্য প্রথম আউটপুট Noob 5হ'ল RRRRRUCALCAYRRRRARRRRDBBBAA, যা উত্পাদন করে N33b @এবং আপনার দ্বিতীয় আউটপুট হ'ল LLDAAYRRRRAUBBARBBBCAযা উত্পাদন করে 4oo3 e। যেমনটি দাঁড়িয়েছে, আপনার বর্তমান স্কোর 5, কারণ আপনার প্রোগ্রামটি কেবল প্রথম 3 পরীক্ষার ক্ষেত্রে বৈধ কমান্ড সিকোয়েন্সগুলি মুদ্রণ করে।
— মেগো
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.