कई पुराने गेम बॉय गेम को अक्सर उपयोगकर्ता से स्ट्रिंग इनपुट की आवश्यकता होती है। हालांकि, कोई कीबोर्ड नहीं था। इसे उपयोगकर्ता को "कीबोर्ड स्क्रीन" की तरह प्रस्तुत करके नियंत्रित किया गया था:

'चरित्र सूचक' पत्र ए उपयोगकर्ता के साथ एक वांछित चरित्र पर नेविगेट होगा पर शुरू होगा D- पैड के चार बटन ( UP, DOWN, LEFTऔर RIGHT), तो प्रेस BUTTON Aअंतिम स्ट्रिंग से संलग्न करने के लिए।

कृपया ध्यान दें:

ग्रिड चारों ओर से घूमता है , इसलिएUPअक्षर A पर बार-बारदबानेपर आपको T पर ले जाएगा।
'वर्ण सूचक' एक पत्र को संलग्न करने के बाद रखा जाता है

चुनौती

उपरोक्त कीबोर्ड में केस बदलने के विकल्प हैं और एक अनियमित आकार है। तो, सरलता के लिए, इस चुनौती में हम निम्नलिखित कीबोर्ड का उपयोग करेंगे (नीचे दाईं ओर ASCII char 32, एक स्थान है):

A B C D E F G
H I J K L M N
O P Q R S T U
V W X Y Z .

इस तरह कीबोर्ड पर टाइप करना बेहद धीमा है - इसलिए, इसे आसान बनाने के लिए, आपका कार्य एक प्रोग्राम लिखना है जो उपयोगकर्ता को किसी दिए गए स्ट्रिंग को टाइप करने का सबसे तेज़ संभव तरीका बताता है । यदि कई तेज़ तरीके हैं, तो आपको केवल एक दिखाने की आवश्यकता है।

आउटपुट कुंजी होनी चाहिए:

> के लिये RIGHT
< के लिये LEFT
^ के लिये UP
v के लिये DOWN
.के लिए BUTTON A(वर्तमान पत्र स्ट्रिंग में संलग्न करें)

उदाहरण के लिए, जब स्ट्रिंग दी जाती है DENNIS, तो समाधान इस तरह दिखेगा:

>>>.>.>>v..>>.>>>v.

नियम / विवरण

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

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

आमतौर पर एक ही लंबाई के कई समाधान होते हैं। प्रत्येक परीक्षण मामले के लिए, मैंने इष्टतम लंबाई और एक उदाहरण शामिल किया है। आपको अपने उत्तर में लंबाई को मुद्रित करने की आवश्यकता नहीं है, बस समाधान।

FLP.TKC  ->  25 steps:  <<.<v.<<<v.<<<v.^.<<^.<^.
MOYLEX   ->  23 steps:  <<v.>>v.>>>v.>^^.^.<<^.
FEERSUM  ->  18 steps:  <<.<..<vv.>.>>.<^.
MEGO     ->  14 steps:  <<v.<^.>>.>vv.

A CAT    ->  17 steps:  .<^.>>>v.<<.<<vv.
BOB      ->  10 steps:  >.<vv.>^^.

(space)  ->  3 steps:   <^.
(empty)  ->  0 steps:   (empty)

आप मेरे टेस्टकेस जनरेटर को repl.it पर देख सकते हैं - अगर कोई बग हैं तो कृपया मुझे सूचित करें।

प्रस्तुतियाँ के लिए आप सभी का धन्यवाद! उपयोगकर्ता ngn वर्तमान में 61 बाइट्स के साथ विजेता है, लेकिन अगर किसी को एक छोटा समाधान मिल सकता है, तो छोटे हरे रंग की टिक को स्थानांतरित किया जा सकता है;)

code-golf string keyboard

— FlipTack
स्रोत

ध्यान दें कि यह सैंडबॉक्स के माध्यम से किया गया है, और इसी तरह की एक चुनौती मिली थी, लेकिन चैट और सैंडबॉक्स में चर्चा से यह निष्कर्ष निकला कि यह एक

— डुबकी

मुझे लगा कि यह बहुत जाना-पहचाना लग रहा है, लेकिन यह इस एक की नकल नहीं है ।

4

डायलॉग एपीएल , 61 बाइट्स

4 7∘{∊'.',⍨⍉↑b⍴¨¨'^v' '<>'⌷¨⍨⊂¨a>b←a⌊⍺-a←⍺|↓2-/0,⍺⊤⍵⍳⍨⎕a,'.'}

मान लिया गया है ⎕IO←0

⎕a,'.' एक पूर्ण विराम के बाद वर्णमाला

⍵⍳⍨0..26 ( ' 'और अन्य सभी 27 हो जाएगा) के रूप में वहाँ तर्क के आकर्षण पाते हैं

⍺⊤बेस 7 में एनकोड करें (ध्यान दें कि बाएं arg ⍺बाध्य है 4 7), 2 × n मैट्रिक्स प्राप्त करें

0, बाईं ओर ज़ीरो प्रिपेंड करें

2-/ आसन्न कॉलम के बीच अंतर

↓ मैट्रिक्स को वैक्टर की एक जोड़ी में विभाजित करें

a←⍺| उन्हें क्रमशः modulo 4 और 7 लें, असाइन करें a

b←a⌊⍺-abके छोटे aऔर इसके मॉड्यूलर उलटा बनाते हैं

'^v' '<>'⌷¨⍨⊂¨a>bचुनें ^या vप्रथम वेक्टर के लिए और <या >, दूसरे के लिए जहां के आधार पर aसे भिन्नb

b⍴¨¨उन में से प्रत्येक को दोहराने bबार

⍉↑ दो वैक्टर को एक मैट्रिक्स में मिलाएं और इसे स्थानांतरित करें, एक n × 2 मैट्रिक्स प्राप्त करें

'.',⍨append .-s दाईं ओर

∊ समतल करना

— NGN
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 147 बाइट्स

s=>s.replace(/./g,c=>(q=p,p="AHOVBIPWCJQXDKRYELSZFMY.GNU ".indexOf(c),"<<<>>>".substring(3,((p>>2)+10-(q>>2))%7)+["","v","vv","^"][p-q&3]+"."),p=0)

एक दिलचस्प व्यवहार substringयह है कि यह उन तर्कों का आदान-प्रदान करता है यदि दूसरा पहले से कम है। इसका मतलब यह है कि अगर मैं -3 और 3 के बीच की संख्या के रूप में बाएं / दाएं प्रेस की इष्टतम संख्या की गणना करता हूं, तो मैं 3 जोड़ सकता हूं, और <<<>>>3 पर शुरू करने का विकल्प ले सकता हूं और मुझे सही संख्या में तीर मिलेंगे। इस बीच नीचे / ऊपर की प्रेस को एक बिटवाइज़ और 3 के साथ पंक्तियों में अंतर का उपयोग करके एक सरणी को देखकर बस नियंत्रित किया जाता है; यह तरीका थोड़ा कम है क्योंकि इसमें ऐरे तत्व कम हैं।

— नील
स्रोत

4

रूबी, 107 बाइट्स

->s{c=0
s.tr(". ","[\\").bytes{|b|b-=65
print ["","^","^^","v"][c/7-b/7],(d=(c-c=b)%7)>3??>*(7-d):?<*d,?.}}

परीक्षण कार्यक्रम में अपराजित

f=->s{                                 #Input in s.
  c=0                                  #Set current position of pointer to 0.
  s.tr(". ","[\\").                    #Change . and space to the characters after Z [\
  bytes{|b|                            #For each byte b,
    b-=65                              #subtract 65 so A->0 B->1 etc.
    print ["","^","^^","v"][c/7-b/7],  #Print the necessary string to move vertically.
    (d=(c-c=b)%7)>3?                   #Calculate the horizontal difference c-b (mod 7) and set c to b ready for next byte.
       ?>*(7-d):?<*d,                  #If d>3 print an appropriate number of >, else an appropriate number of <.
    ?.                                 #Print . to finish the processing of this byte.
  }
}

#call like this and print a newline after each testcase
f["FLP.TKC"];puts  
f["MOYLEX"];puts   
f["FEERSUM"];puts  
f["MEGO"];puts     
f["A CAT"];puts    
f["BOB"];puts

— स्तर नदी सेंट
स्रोत

1

मैथेमेटिका, 193 बाइट्स

गोल्फ़

StringJoin@@(StringTake[">>><<<",Mod[#〚2〛,7,-3]]<>StringTake["vv^",Mod[#〚1〛,4,-1]]<>"."&/@Differences[FirstPosition[Partition[ToUpperCase@Alphabet[]~Join~{"."," "},7],#]&/@Characters["A"<>#]])&

पठनीय

In[1]:= characters = ToUpperCase@Alphabet[]~Join~{".", " "}

Out[1]= {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", ".", " "}

In[2]:= keyboard = Partition[characters, 7]

Out[2]= {{"A", "B", "C", "D", "E", "F", "G"}, {"H", "I", "J", "K", "L", "M", "N"}, {"O", "P", "Q", "R", "S", "T", "U"}, {"V", "W", "X", "Y", "Z", ".", " "}}

In[3]:= characterPosition[char_] := FirstPosition[keyboard, char]

In[4]:= xToString[x_] := StringTake[">>><<<", Mod[x, 7, -3]]

In[5]:= yToString[y_] := StringTake["vv^", Mod[y, 4, -1]]

In[6]:= xyToString[{y_, x_}] := xToString[x] <> yToString[y] <> "."

In[7]:= instructionsList[input_] := xyToString /@ Differences[characterPosition /@ Characters["A" <> input]]

In[8]:= instructions[input_] := StringJoin @@ instructionsList[input]

In[9]:= instructions["DENNIS"]

Out[9]= ">>>.>.>>v..>>.>>>v."

— ngenisis
स्रोत

1

पायथन 2, 298 बाइट्स

यह होना चाहिए की तुलना में लंबा है, लेकिन ...

def l(c):i="ABCDEFGHIJKLMNOPQRSTUVWXYZ. ".index(c);return[i%7,i/7]
def d(f,t,a=abs):
 v,h=l(t)[1]-l(f)[1],l(t)[0]-l(f)[0]
 if a(h)>3:h=h-7*h/a(h)
 if a(v)>2:v=v-4*v/a(v)
 return'^v'[v>0]*a(v)+'<>'[h>0]*a(h)
s="A"+input()
print''.join([d(p[0],p[1])+'.'for p in[s[n:n+2]for n in range(len(s))][:-1]])

किसी भी तरह की सहायता का स्वागत किया जाएगा!

उद्धरण चिह्नों में इनपुट लेता है।

l कीबोर्ड में एक चरित्र का स्थान देता है।

यदि यह कीबोर्ड के चारों ओर around रैप ’करने के लिए इष्टतम होगा, तो जाँच के लिए दो ifबयान बीच में dहैं।

इनपुट, sइसके लिए पूर्व "A"निर्धारित है क्योंकि कर्सर की प्रारंभिक स्थिति है A।

हम जोड़े में स्ट्रिंग के माध्यम से लूप करते हैं, पिछले एक (जो एक जोड़ी नहीं है [:-1]) को त्यागते हुए, जोड़ी के दो हिस्सों के बीच न्यूनतम दूरी का पता लगाते हैं।

Flp.Tkc के लिए धन्यवाद मुझे यह बताने के लिए कि मैं हर बार a=absकहने के बजाय कर सकता हूं abs!

— डैनियल
स्रोत

0

जावा 8, 1045 बाइट्स

गोल्फ़

staticchar[][]a={{'A','B','C','D','E','F','G'},{'H','I','J','K','L','M','N'},{'O','P','Q','R','S','T','U'},{'V','W','X','Y','Z','.',''}};staticintm=Integer.MAX_VALUE;staticStringn="";staticboolean[][]c(boolean[][]a){boolean[][]r=newboolean[4][];for(inti=0;i<4;i)r[i]=a[i].clone();returnr;}staticvoidg(inti,intj,boolean[][]v,chard,Stringp){v[i][j]=true;if(a[i][j]==d&&p.length()<m){m=p.length();n=p;}if(i-1<0){if(!v[3][j])g(3,j,c(v),d,p"^");}elseif(!v[i-1][j])g(i-1,j,c(v),d,p"^");if(i1>3){if(!v[0][j])g(0,j,c(v),d,p"v");}elseif(!v[i1][j])g(i1,j,c(v),d,p"v");if(j-1<0){if(!v[i][6])g(i,6,c(v),d,p"<");}elseif(!v[i][j-1])g(i,j-1,c(v),d,p"<");if(j1>6){if(!v[i][0])g(i,0,c(v),d,p">");}elseif(!v[i][j1])g(i,j1,c(v),d,p">");}publicstaticvoidmain(String[]args){boolean[][]v=newboolean[4][7];Scannerx=newScanner(System.in);Strings=x.next();Stringpath="";intp=0;intq=0;for(inti=0;i<s.length();i){chart=s.charAt(i);g(p,q,c(v),t,"");path=n".";n="";m=Integer.MAX_VALUE;for(intj=0;j<4;j){for(intk=0;k<7;k){if(a[j][k]==t){p=j;q=k;}}}}System.out.println(path);}

पठनीय

static char[][] a = {
        {'A','B','C','D','E','F','G'},
        {'H','I','J','K','L','M','N'},
        {'O','P','Q','R','S','T','U'},
        {'V','W','X','Y','Z','.',' '}
};
static int m = Integer.MAX_VALUE;
static String n="";


static boolean[][] c(boolean[][] a){
    boolean [][] r = new boolean[4][];
    for(int i = 0; i < 4; i++)
        r[i] = a[i].clone();
    return r;
}

static void g(int i, int j,boolean[][] v,char d,String p) {

    v[i][j] = true;
    if (a[i][j]==d && p.length()<m){
        m=p.length();
        n=p;
    }

    if (i-1<0) {
        if(!v[3][j])
            g(3, j, c(v), d, p + "^");
    }
    else if (!v[i-1][j])
        g(i-1, j, c(v), d, p + "^");


    if (i+1>3) {
        if(!v[0][j])
            g(0, j, c(v), d, p + "v");
    }
    else if(!v[i+1][j])
        g(i+1, j, c(v), d, p + "v");


    if (j-1<0) {
        if(!v[i][6])
            g(i, 6, c(v), d, p + "<");
    }
    else if (!v[i][j-1])
        g(i, j-1, c(v), d, p + "<");


    if (j+1>6) {
        if (!v[i][0])
            g(i, 0, c(v), d, p + ">");
    }
    else if (!v[i][j+1])
        g(i, j+1, c(v), d, p + ">");

}

public static void main(String[] args) {
    boolean[][] v = new boolean[4][7];
    Scanner x = new Scanner(System.in);
    String s = x.next();
    String path="";
    int p=0;
    int q=0;
    for(int i=0;i<s.length();i++){
        char t=s.charAt(i);
        g(p,q,c(v),t,"");
        path+=n+".";
        n="";
        m=Integer.MAX_VALUE;
        for(int j=0;j<4;j++){
            for(int k=0;k<7;k++){
                if(a[j][k]==t) {
                    p=j;
                    q=k;
                }
            }
        }

    }
    System.out.println(path);
}

व्याख्या

समाधान एक प्रत्यक्ष दृष्टिकोण है: खराब रूप से अनुकूलित ब्रूट बल। विधि g(...)एक मूल गहराई है जो पहले प्रत्येक क्रमपरिवर्तन (ऊपर, नीचे, बाएं, दाएं) से होकर गुजरती है। परीक्षण मामलों के लिए कुछ मामूली संशोधनों के साथ मुझे आउटपुट मिलता है:

<<.v<.v<<<.v<<<.^.^<<.^<.
v<<.v>>.v>>>.^^>.^.^<<.
<<.<..^^<.>.>>.^<.
v<<.^<.>>.^^>.
.^<.v>>>.<<.^^<<.
>.^^<.^^>.
^<.
// new line for the last

— Bobas_Pett
स्रोत

एक गेम ब्वॉय पर कुशल टंकण