वर्चुअल कीबोर्ड टेक्स्ट इनपुट

22

पारंपरिक कीबोर्ड के बिना आधुनिक गेम कंसोल और अन्य उपकरणों पर, इनपुट टेक्स्ट की कोशिश एक बुरा सपना है। वर्चुअल कीबोर्ड पर कुछ बटन और जॉयस्टिक के साथ टाइप करना कष्टप्रद होता है, और मुझे यथासंभव कुछ आंदोलनों / बटन प्रेस करना पसंद है।

आपके द्वारा उपयोग किया जा रहा कीबोर्ड इस तरह दिखता है:

+---+---+---+---+---+---+---+---+---+---+
| 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: निवेशन पॉइंटर की स्थिति में चयनित वर्ण डालें

केवल इनपुट इनपुट स्ट्रिंग वाले ASCII वर्णों को देखते हुए जिन्हें उपरोक्त कीबोर्ड और कमांड्स (माचिस [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 आदेश।

हालाँकि आपका सबमिशन, भोले दृष्टिकोण से बेहतर करने का प्रयास करता है। प्रत्येक इनपुट स्ट्रिंग के लिए, आपके सबमिशन को अंक प्राप्त होंगे कमांड्स की संख्या के बराबर अनुभवहीन दृष्टिकोण माइनस आपके सबमिशन आउटपुट की कमांड की संख्या का उपयोग करता है। आपका कुल स्कोर व्यक्तिगत अंकों का योग होगा।

नियम

  • प्रस्तुतियाँ Cloud9 मुक्त वर्चुअल कार्यस्थान पर चलाया जाएगा । कार्यक्षेत्र में 512 MB RAM, 2 GB डिस्क स्थान, 8 Intel (R) Xeon (R) CPUs @ 2.50 GHz (पूर्ण सीपीयू जानकारी, चलाने cat /proc/cpuinfoसे मिली, यहाँ मिल सकती है ), और 64-बिट Ubuntu 14.04 चला रहा है भरोसेमंद। आप अपनी प्रविष्टि को चलाने और स्कोर करने के लिए परीक्षण कार्यक्षेत्र में पहुंच का अनुरोध कर सकते हैं, या मैं इसे आपके लिए स्कोर कर सकता हूं।
  • टेस्ट केस के अनुसार सबमिशन एक बार चलाया जाएगा। रनों के बीच भंडारण की स्थिति निषिद्ध है। यदि आवश्यक हो तो इनपुट फ़ाइल को पढ़ने के संभावित अपवाद के साथ स्रोत फ़ाइल के अलावा स्रोत फ़ाइलों (जो रन के बीच संशोधित नहीं किया जा सकता है) के अलावा किसी भी फाइल से नहीं लिख सकते हैं।
  • प्रस्तुतियाँ प्रत्येक परीक्षण मामले के लिए रनटाइम के 1 मिनट तक सीमित हैं। सबमिशन कई समाधानों का उत्पादन कर सकता है, लेकिन आवंटित समय के भीतर केवल अंतिम वैध समाधान का उपयोग स्कोरिंग के लिए किया जाएगा। आवंटित समय के भीतर किसी भी वैध समाधान का उत्पादन करने में विफलता के परिणामस्वरूप उस परीक्षण मामले के लिए 0 का स्कोर होगा।
  • कृपया अपने सबमिशन को कैसे लागू करें, साथ ही किसी भी उपकरण / लाइब्रेरी को स्थापित करने की दिशा में दिशा-निर्देश शामिल करें, जो एक मानक उबंटू 14.04 इंस्टॉल के साथ शामिल नहीं हैं।
  • विजेता सबसे बड़े स्कोर के साथ प्रस्तुत होगा। एक टाई होने की स्थिति में, बेहतर एल्गोरिथम जटिलता के साथ सबमिशन जीत जाएगा। यदि टाई अभी भी हल नहीं हुई है, तो स्कोर और एल्गोरिथम जटिलता तक पहुंचने वाला पहला सबमिशन जीत जाएगा।
  • प्रस्तुतियाँ परीक्षण के मामलों के लिए अनुकूलन नहीं कर सकती हैं। यदि मुझे लगता है कि आवश्यकता है, तो मुझे परीक्षण मामलों को बदलने का अधिकार सुरक्षित है।

परीक्षण के मामलों

प्रारूप: 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
@Mego: मुझे लगता है कि वह कह रहा है कि उसका समाधान भोले से भी बदतर था । : पी
— एल'एंडिया स्ट्रोमैन
2
मैं सहमत हूं, गेमिंग कंसोल कीबोर्ड चूसते हैं ।
— R
यदि कार्यक्रम एक मिनट के भीतर समाप्त नहीं होता है, लेकिन उस समय के भीतर एक या अधिक समाधान प्रिंट करता है तो क्या होता है? क्या समाप्त नहीं करने के लिए कोई जुर्माना है?
— 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;
}

"Gcc virtualKeyboard.c" के रूप में संकलित करें। इसे तर्क के बिना चलाएं "./a.out"। यह स्टड से इनपुट को पढ़ता है और आउटपुट को stdout में लिखता है।

— 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"
का संकलन " उपयोग" virtualKeyboard "string" है

— dj0wns
स्रोत
1
यह कई इनपुट्स पर मान्य कमांड दृश्यों का निर्माण करने में विफल है। उदाहरण के लिए, आपका पहला आउटपुट Noob 5है RRRRRUCALCAYRRRRARRRRDBBBAA, जो उत्पादन करता है N33b @, और आपका दूसरा आउटपुट हैLLDAAYRRRRAUBBARBBBCA , जो उत्पादन करता है 4oo3 e। जैसा कि यह खड़ा है, आपका वर्तमान स्कोर 5 है, क्योंकि आपका प्रोग्राम केवल पहले 3 परीक्षण मामलों के लिए मान्य कमांड अनुक्रम प्रिंट करता है।
— मेगो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.