Manövriere das Gitter!

11

Einweisung

Sie sind ein Bot in einem 2D-Raster, das sich unendlich in alle vier Richtungen erstreckt, Nord, Süd, Ost und West. Wenn Sie eine Nummer erhalten, müssen Sie den Bot bewegen, damit Sie zur Zielnummer gelangen.

So funktioniert das Raster:

Sie können sich in 4 Richtungen bewegen: Nord, Süd, Ost oder West. Sobald Sie eine Zelle verlassen, dürfen Sie nicht mehr zu dieser Zelle zurückkehren (so effektiv, dass sie von der Karte gelöscht wurde).

Es gibt einen "Zähler", der geht 1234567890(also geht es von 1zu 2... bis zu 9, dann zu 0, dann zurück zu 1wieder), der sich bei jeder Bewegung ändert.

Sie haben auch einen "Wert", der bei 0 beginnt.

Sobald Sie sich in eine Richtung bewegen, wird eine mathematische Operation ausgeführt, je nachdem, in welche Richtung Sie sich bewegen:

  • Norden: Ihr Wert wird durch counter ( value += counter) erhöht .
  • Ost: Ihr Wert wird durch counter ( value -= counter) dekrementiert .
  • Süd: Ihr Wert wird mit counter ( value *= counter) multipliziert .
  • West: Ihr Wert wird durch counter ( value /= counter) geteilt.
    • Division ist also eine ganzzahlige Division 5/2 -> 2.
    • Sie dürfen nicht durch teilen 0.

Beispiel:

Wenn sich der Bot dreimal nach Norden bewegt:

  • Die erste "Nord" -Zug erhöht den Zähler auf 1und addiert diesen zum Wert (der jetzt ist 1).
  • Die zweite "Nord" -Zug erhöht den Zähler auf 2und addiert diesen zum Wert (der jetzt ist 3).
  • Die dritte "Nord" -Zug erhöht den Zähler auf 3und addiert diesen zum Wert (der jetzt ist 6).

Der Endwert ist 6.

Gehe nach Norden und dann wieder nach Süden:

  • Die erste "Nord" -Zug erhöht den Zähler auf 1und addiert diesen zum Wert (der jetzt ist 1).
  • Der zweite "Süd" -Zugfehler, da die Zelle, auf der der Bot sich bewegen möchte, entfernt wird (aus dem ersten Zug).

Es gibt keinen endgültigen Wert, da der Bot einen Fehler gemacht hat.

Herausforderung

Ihre Herausforderung besteht darin, ein Programm zu schreiben, wenn Sie unter Angabe einer Nummer die geeigneten Anweisungen für den Bot erstellen, damit der Endwert des Bots dieser Nummer entspricht.

Wenn die Zahl also lautet 6, wäre eine gültige Lösung dafür:

nnn

(Der Bot bewegt sich dreimal hintereinander nach Norden).

Ihre Testwerte sind:

49445094, 71259604, 78284689, 163586986, 171769219, 211267178, 222235492, 249062828, 252588742, 263068669, 265657839, 328787447, 344081398, 363100288, 363644732, 372642304, 374776630, 377945535, 407245889, 467229432, 480714605, 491955034, 522126455, 532351066, 542740616, 560336635, 563636122, 606291383, 621761054, 648274119, 738259135, 738287367, 748624287, 753996071, 788868538, 801184363, 807723631, 824127368, 824182796, 833123975, 849666906, 854952292, 879834610, 890418072, 917604533, 932425141, 956158605, 957816726, 981534928, 987717553

(Dies sind 50 Zufallszahlen von 1 bis 1 Milliarde.)

Ihre Punktzahl ist die Gesamtzahl der Züge, die für alle 50 Zahlen ausgeführt wurden - je weniger Züge, desto besser. Bei einem Unentschieden gewinnt die Person, die ihren Code früher eingereicht hat.

Technische Daten

  • Sie erhalten garantiert eine positive Ganzzahl für die Eingabe.
  • Ihre valueVariable darf zu keinem Zeitpunkt für Ihre generierten Pfade nach oben 2^31-1oder unten gehen -2^31.
  • Ihr endgültiges Programm muss in eine Antwort passen (also < 30,000Bytes).
  • Sie dürfen nur 10 Zahlen fest codieren.
  • Ihr Programm muss für jeden Testfall innerhalb von 5 Minuten auf einem angemessenen Laptop ausgeführt werden.
  • Die Ergebnisse MÜSSEN jedes Mal gleich sein, wenn das Programm für jede Nummer ausgeführt wird.
math  code-challenge 
— Clismique
quelle
Sollte dies nicht eine Code-Herausforderung anstelle von Atomic-Code-Golf sein? Sie bewerten nicht nach der Größe des eingereichten Programms, auch nicht als Tie-Breaker. Sie bewerten nach der Größe der Ausgabe, was dies zu einer algorithmischen Herausforderung und nicht zu einem Code-Golf-Problem macht.
— Marinus
@ Marinus behoben. Ich dachte, Atomic Code Golf wäre für das Programm - ich muss verwirrt gewesen sein.
— Clismique
1
Gibt es einen Beweis dafür, dass dies möglich ist?
— Zerstörbare Zitrone
1
1. Ich denke, Sie sollten eine Regel hinzufügen, dass Einsendungen auf einem Computer mit den Spezifikationen X und einem Zeitrahmen Y ausgeführt werden müssen. Eine der aktuellen Antworten behauptet eine perfekte Punktzahl, aber ich bezweifle, dass sie tatsächlich berechnet werden kann. 2. Sie dürfen keine Werte über [...] berechnen. Das bezieht sich auf die Variable value, ja? Zumindest für mich klingt es nach einer Einschränkung der Implementierung, nicht nach dem eigentlichen Algorithmus.
— Dennis
@ Tennis Denken Sie, dass 10 Minuten für alle 50 Testfälle ausreichen?
— Clismique

Antworten:

3

C ++: Punktzahl = 453.324.048

OK, ich brauchte etwas Zeit, um das zu überarbeiten, aber so habe ich es gelöst.

Nachdem ich den Lösungsraum studiert hatte, entschied ich, dass meine Strategie sein würde:

  1. Verwendet die Südstufen, um der Zielnummer so nahe wie möglich zu kommen
    1. Wenn das Ziel positiv ist, folgen Sie diesem Pfad: nnnesssssessssssss
    2. Wenn das Ziel negativ ist, folgen Sie diesem Pfad: esssssssseessssss c. Wenn das Ziel zwischen 0 und 20 liegt, lösen Sie es "auf die altmodische Weise" (Spur und Fehler über jeden möglichen Pfad, bis wir es erreichen).
    3. Sobald wir unseren "besten Platz" haben (dem Ziel so nahe kommen, ohne "über" zu gehen), können wir möglicherweise näher kommen, indem wir mit 2 oder 3 multiplizieren. Nehmen Sie also zwischen 0 und 9 Schritte nach Osten und dann einen Schritt nach Süden. Halten Sie den Pfad, der uns dem Ziel am nächsten bringt.
    4. "Laufen" Sie nach Norden oder Osten, bis wir uns innerhalb von 45 Punkten des Ziels befinden (alle 10 Schritte nach Norden addieren Sie 45 Punkte zur Punktzahl, wie weise, alle 10 Schritte nach Osten, reduziert die Punktzahl um 45).
  2. Machen Sie noch ein paar Schritte in die gleiche Richtung, bis wir uns innerhalb von 10 Punkten des Ziels befinden
  3. Mach "die alte Mode" von diesem Punkt an, es sollte jetzt nicht so schwer sein.

Hier ist mein Ergebnis: Die Gesamtpunktzahl beträgt 453324048

Und die Wege:

  0) to reach   49445094, it takes   1311037 steps, by doing: nnnesssssesssssseeeeese(n *     1311010)enen
  1) to reach   71259604, it takes   1320313 steps, by doing: nnnesssssesssssseeeeeese(n *     1320280)nnnnnneee
  2) to reach   78284689, it takes   1956998 steps, by doing: nnnesssssesssssseeeeeees(e *     1956970)eeee
  3) to reach  163586986, it takes   2483885 steps, by doing: nnnesssssessssssse(n *     2483860)nnnnnnn
  4) to reach  171769219, it takes   4302163 steps, by doing: nnnesssssessssssse(n *     4302130)nnnnnnnnnnennnn
  5) to reach  211267178, it takes  13079485 steps, by doing: nnnesssssessssssse(n *    13079460)nnnnnen
  6) to reach  222235492, it takes  15516886 steps, by doing: nnnesssssessssssse(n *    15516860)nnnnnnnn
  7) to reach  249062828, it takes  12390325 steps, by doing: nnnesssssessssssseeees(e *    12390290)eeeeenenneene
  8) to reach  252588742, it takes  11606785 steps, by doing: nnnesssssessssssseeees(e *    11606760)een
  9) to reach  263068669, it takes   9277915 steps, by doing: nnnesssssessssssseeees(e *     9277880)eeeeenennneee
 10) to reach  265657839, it takes   8702543 steps, by doing: nnnesssssessssssseeees(e *     8702510)eeeeenennee
 11) to reach  328787447, it takes   5326312 steps, by doing: nnnesssssessssssseeeese(n *     5326280)nnnnennnn
 12) to reach  344081398, it takes   8724966 steps, by doing: nnnesssssessssssseeeese(n *     8724940)enn
 13) to reach  363100288, it takes  12951386 steps, by doing: nnnesssssessssssseeeese(n *    12951360)enn
 14) to reach  363644732, it takes  13072373 steps, by doing: nnnesssssessssssseeeese(n *    13072340)nnnnnnnnen
 15) to reach  372642304, it takes  15071833 steps, by doing: nnnesssssessssssseeeese(n *    15071800)nnnnnnnenn
 16) to reach  374776630, it takes  15546133 steps, by doing: nnnesssssessssssseeeese(n *    15546100)nnnnnenene
 17) to reach  377945535, it takes  16250331 steps, by doing: nnnesssssessssssseeeese(n *    16250300)nnnnennn
 18) to reach  407245889, it takes  11107325 steps, by doing: nnnesssssessssssseeeees(e *    11107300)ne
 19) to reach  467229432, it takes   2222403 steps, by doing: nnnesssssessssssseeeeese(n *     2222370)nnnnnnnee
 20) to reach  480714605, it takes   5219109 steps, by doing: nnnesssssessssssseeeeese(n *     5219080)neenn
 21) to reach  491955034, it takes   7716983 steps, by doing: nnnesssssessssssseeeeese(n *     7716950)nnnnennnn
 22) to reach  522126455, it takes  14421745 steps, by doing: nnnesssssessssssseeeeese(n *    14421710)nnnnnneneee
 23) to reach  532351066, it takes  16693875 steps, by doing: nnnesssssessssssseeeeese(n *    16693850)n
 24) to reach  542740616, it takes  14866179 steps, by doing: nnnesssssessssssseeeeees(e *    14866150)eeeen
 25) to reach  560336635, it takes  10955953 steps, by doing: nnnesssssessssssseeeeees(e *    10955920)eeeeennen
 26) to reach  563636122, it takes  10222731 steps, by doing: nnnesssssessssssseeeeees(e *    10222700)eeeeene
 27) to reach  606291383, it takes    743785 steps, by doing: nnnesssssessssssseeeeees(e *      743760)e
 28) to reach  621761054, it takes   2693968 steps, by doing: nnnesssssessssssseeeeeese(n *     2693940)nnn
 29) to reach  648274119, it takes   8585761 steps, by doing: nnnesssssessssssseeeeeese(n *     8585730)nnnnnn
 30) to reach  738259135, it takes   5286413 steps, by doing: nnnesssssessssssseeeeeees(e *     5286380)eeneneee
 31) to reach  738287367, it takes   5280141 steps, by doing: nnnesssssessssssseeeeeees(e *     5280110)nneenn
 32) to reach  748624287, it takes   2983042 steps, by doing: nnnesssssessssssseeeeeees(e *     2983010)eeeenee
 33) to reach  753996071, it takes   1789313 steps, by doing: nnnesssssessssssseeeeeees(e *     1789280)eeeennee
 34) to reach  788868538, it takes   5960183 steps, by doing: nnnesssssessssssseeeeeeese(n *     5960150)nnenene
 35) to reach  801184363, it takes   8697033 steps, by doing: nnnesssssessssssseeeeeeese(n *     8697000)nnenene
 36) to reach  807723631, it takes  10150197 steps, by doing: nnnesssssessssssseeeeeeese(n *    10150170)n
 37) to reach  824127368, it takes  13795475 steps, by doing: nnnesssssessssssseeeeeeese(n *    13795440)nnnnnnnne
 38) to reach  824182796, it takes  13807795 steps, by doing: nnnesssssessssssseeeeeeese(n *    13807760)nnnnnenee
 39) to reach  833123975, it takes  15794722 steps, by doing: nnnesssssessssssseeeeeeese(n *    15794690)nennnn
 40) to reach  849666906, it takes  14397917 steps, by doing: nnnesssssessssssseeeeeeees(e *    14397880)eeeeeeeenee
 41) to reach  854952292, it takes  13223389 steps, by doing: nnnesssssessssssseeeeeeees(e *    13223350)eeeeeeeeneeen
 42) to reach  879834610, it takes   7693981 steps, by doing: nnnesssssessssssseeeeeeees(e *     7693950)eeenn
 43) to reach  890418072, it takes   5342102 steps, by doing: nnnesssssessssssseeeeeeees(e *     5342070)eeennn
 44) to reach  917604533, it takes    699395 steps, by doing: nnnesssssessssssseeeeeeeese(n *      699360)nnnneene
 45) to reach  932425141, it takes   3992863 steps, by doing: nnnesssssessssssseeeeeeeese(n *     3992830)nennnn
 46) to reach  956158605, it takes   9266963 steps, by doing: nnnesssssessssssseeeeeeeese(n *     9266930)nnnnen
 47) to reach  957816726, it takes   9635434 steps, by doing: nnnesssssessssssseeeeeeeese(n *     9635400)nnnennn
 48) to reach  981534928, it takes  14906145 steps, by doing: nnnesssssessssssseeeeeeeese(n *    14906110)nnnnnnnn
 49) to reach  987717553, it takes  16280059 steps, by doing: nnnesssssessssssseeeeeeeese(n *    16280030)nn

Ich bin mir sicher, dass es eine Möglichkeit gibt, dies zu verbessern, indem Sie einige "Süd / West" -Zugbewegungen durchführen (zum Beispiel durch 4 dividieren und mit 5 multiplizieren). Aber es zu codieren und sicherzustellen, dass Sie nicht über die Runde gehen oder gefangen werden, ist schwierig.

Ein anderer Lösungspfad könnte darin bestehen, zu versuchen, vom Ziel zurück zu einer "vernünftigen" Zahl zu gelangen und dann einfach einen Weg zu dieser kleineren Zahl zu finden. aber Sie müssen es richtig "zielen", damit die Schrittnummer übereinstimmt. knifflig, könnte aber der beste Weg sein, dies zu lösen.

Wie auch immer, hier ist mein Code-Code:

#include <stdio.h>
#include <vector>
#include <queue>;

using namespace std;

long long upperLimit;
long long lowerLimit;
bool bDebugInfo = false;
//bool bDebugInfo = true;

//  a point struct (x and y)
struct point
{
    int x;
    int y;

    point():x(0),y(0)
    {
    }

    bool operator ==(const point& other)
    {
        return (x==other.x) && (y==other.y);
    }

    void ApplyDirection(char direction)
    {
        switch (direction)
        {
        case 'n':
            y++;
            break;
        case 'w':
            x--;
            break;
        case 'e':
            x++;
            break;
        case 's':
            y--;
            break;
        }
    }
};

// each state is of this formate
struct botState
{
    int nStep;
    long long number;
    vector<char> path;

    botState()
        :nStep(0),
        number(0)
    {
    }

    botState* clone()
    {
        botState* tmp = new botState();
        tmp->nStep = nStep;
        tmp->number = number;
        tmp->path = path;
        return tmp;
    }

    void clone(botState* other)
    {
        nStep = other->nStep;
        number = other->number;
        path = other->path;
    }

};

bool changeNumberWithDirection(long long &number, char direction, int step)
{
    switch (direction)
    {
    case 'n':
        number += (step%10);
        break;
    case 'w':
        if (step%10)
            number /= (step%10);
        else
            return false;
        break;
    case 'e':
        number -= (step%10);
        break;
    case 's':
        number *= (step%10);
        break;

    default:
        return false;
    }

    return true;
}

bool tryToAddStep(queue<botState*>& queueOfStates, const botState* pState, char direction, char cStarDirection)
{
    botState* pTmpState;
    long long newNumber;
    int newStep = pState->nStep+1;

    newNumber = pState->number;
    if (!changeNumberWithDirection(newNumber, direction, newStep))
        return false;

    if (newNumber > upperLimit)
        return false;

    if (newNumber < lowerLimit)
        return false;

    if ((newNumber == 0) && (newStep%10 == 0))
        return false;                // no need to return back to 0 after 10 or more steps, we already have better ways to do this.

    // build the x,y points of the path up to this point
    point tmpPoint;
    vector<point> pointsInPath;
    pointsInPath.push_back(tmpPoint);

    for (int i=0; i<pState->path.size(); i++)
    {
        if (pState->path.at(i) == '*')
        {
            for (int j=0; j<100; j++)
            {
                tmpPoint.ApplyDirection(cStarDirection);
                pointsInPath.push_back(tmpPoint);
            }
        }
        else
        {
            tmpPoint.ApplyDirection(pState->path.at(i));
            pointsInPath.push_back(tmpPoint);
        }
    }

    tmpPoint.ApplyDirection(direction);

    // check for over lap
    for (int i=0; i<pointsInPath.size(); i++)
    {
        if (tmpPoint == (pointsInPath.at(i)))
            return false;
    }

    pTmpState = new botState();
    pTmpState->nStep = newStep;
    pTmpState->number= newNumber;
    pTmpState->path  = pState->path;

    pTmpState->path.push_back(direction);

    queueOfStates.push(pTmpState);

    return true;
}

bool isBetterNum(long long newNum, long long oldBest, long long target)
{
    long long newDiff = (newNum  > target) ? newNum  - target : target - newNum ;
    long long oldDiff = (oldBest > target) ? oldBest - target : target - oldBest;

    return (newDiff < oldDiff);
}

bool tryToJumpDown(long long num, botState* pState, int& nTimes)
{
    // if where the bot is, we have a clear path to go as far east as we could ever want, we can just do as many sets of eeeeeeeeee (e*10) as needed, til we are close enough to the target
    point tmpPoint;
    vector<point> pointsInPath;
    pointsInPath.push_back(tmpPoint);

    for (int i=0; i<pState->nStep; i++)
    {
        tmpPoint.ApplyDirection(pState->path.at(i));
        pointsInPath.push_back(tmpPoint);
    }

    for (int i=0; i<pointsInPath.size(); i++)
    {
        if ((pointsInPath.at(i).x > tmpPoint.x) && (pointsInPath.at(i).y == tmpPoint.y))
            return false;  // we have a point blocking our path up!
    }

    long long tmpTimes = (pState->number - num)/45;
    if ((tmpTimes>1) && (tmpTimes<upperLimit))
    {
        tmpTimes--;
        tmpTimes*=10;
        nTimes = (int)tmpTimes;
        pState->nStep+=nTimes;
        pState->number-=(tmpTimes/10)*45;
        pState->path.push_back('*');
        return true;
    }

    return false;
}

bool tryToJumpUp(long long num, botState* pState, int& nTimes)
{
    // if where the bot is, we have a clear path to go as far north as we could ever want, we can just do as many sets of nnnnnnnnnn (n*10) as needed, til we are close enough to the target
    point tmpPoint;
    vector<point> pointsInPath;
    pointsInPath.push_back(tmpPoint);

    for (int i=0; i<pState->nStep; i++)
    {
        tmpPoint.ApplyDirection(pState->path.at(i));
        pointsInPath.push_back(tmpPoint);
    }

    for (int i=0; i<pointsInPath.size(); i++)
    {
        if ((pointsInPath.at(i).x == tmpPoint.x) && (pointsInPath.at(i).y > tmpPoint.y))
            return false;  // we have a point blocking our path up!
    }

    long long tmpTimes = (num - pState->number)/45;
    if ((tmpTimes>1) && (tmpTimes<upperLimit))
    {
        tmpTimes--;
        tmpTimes*=10;
        nTimes = (int)tmpTimes;
        pState->nStep+=nTimes;
        pState->number+=(tmpTimes/10)*45;
        pState->path.push_back('*');
        return true;
    }

    return false;
}

typedef char* PChar;

bool buildPath(long long num, PChar& str, int& nLen, int& nScore, botState* startState, int nTimes)
{
    long long nBest = 0;
    int nMaxSteps = 0;
    long long nMax = 0;
    long long nMin = 0;
    int nCleanUpOnStep= 12;
    long long nFromLastCleanUp = 0;
    bool bInCleanUp = false;
    char cDirection = ' ';

    if (nTimes>0)
        cDirection = 'n';
    else if (nTimes<0)
    {
        cDirection = 'e';
        nTimes*=-1;
    }

    if (startState->nStep >= nCleanUpOnStep)
        nCleanUpOnStep= startState->nStep+10;

    str  = NULL;
    nLen = 0;
    botState* bestState = new botState();
    bestState->clone(startState);
    queue<botState*> queueOfStates;
    queueOfStates.push(bestState);  // put the starting state into the queue

    while (!queueOfStates.empty())       // while we still have states in the queue, process them
    {
        botState* pState = queueOfStates.front();
        queueOfStates.pop();             // take a state out of the queue


        if (!str)                        // no solution yet
        {
            if (pState->number == num)   // check if this is a solution
            {
                // we solved it!
                int nOffset=0;
                nLen = pState->nStep - nTimes + 17;
                str = new char[nLen+1];
                if (bDebugInfo)
                    printf("solved!\n");
                nScore = pState->nStep;
                for (int i=0; i<pState->path.size(); i++)
                {
                    if (pState->path.at(i)=='*')
                    {
                        sprintf(str+i, "(%c * %11d)", cDirection, nTimes);
                        if (bDebugInfo)
                            printf("(%c * %11d)", cDirection, nTimes);
                        nOffset=16;
                    }
                    else
                    {
                        str[i+nOffset] = pState->path.at(i);
                        if (bDebugInfo)
                            printf("%c", str[i+nOffset]);// print solution while making the string
                    }
                }
                if (bDebugInfo)
                    printf("\n");
                str[nLen]='\0';
            }
            else
            {                            // no solution yet, we need to go deeper
                if (pState->number < nMin)
                    nMin = pState->number;

                if (pState->number > nMax)
                    nMax = pState->number;

                if ((!bInCleanUp) && (queueOfStates.size()>1000000))
                {
                    nCleanUpOnStep=nMaxSteps+10;
                    bInCleanUp = true;
                }
                if (pState->nStep > nMaxSteps)
                {                        // a little tracing, so we can see progress
                    nMaxSteps = pState->nStep;
//                    printf("current states have %d steps, reached a max of %lld, and a min of %lld\n", nMaxSteps, nMax, nMin);
                    if (nMaxSteps >= nCleanUpOnStep)
                    {
                        nCleanUpOnStep+=10;
                        bInCleanUp = true;
                    }
                }

                if (isBetterNum(pState->number, nBest, num))
                {                        // a little tracing, so we can see progress
                    nBest = pState->number;
                    if (bDebugInfo)
                        printf("Got closer to the target, %lld, with %d steps (target is %lld, diff is %lld)\n", nBest, pState->nStep, num, num-nBest);
                    if (bestState != pState)
                        delete bestState;
                    bestState = pState;
                }

                if (!bInCleanUp)
                {
                    tryToAddStep(queueOfStates, pState, 'n', cDirection);
                    tryToAddStep(queueOfStates, pState, 'e', cDirection);

                    if (!nTimes)  // once we did the "long walk in one direction" don't do the west or south moves any more
                    {
                        tryToAddStep(queueOfStates, pState, 'w', cDirection);
                        tryToAddStep(queueOfStates, pState, 's', cDirection);
                    }
                }
            }
        }
        if (pState!=bestState)
            delete pState;                  // this is not java, we need to keep the memory clear.

        if ((bInCleanUp) && (queueOfStates.empty()))
        {
            queueOfStates.push(bestState);  // put the starting state into the queue
            bInCleanUp = false;
            long long diff = nFromLastCleanUp-bestState->number;
            if (!nTimes)
            {
                if ((diff>0) && (diff<100))
                    if (tryToJumpDown(num, bestState, nTimes))
                        cDirection = 'e';
                if ((diff<0) && (diff>-100))
                    if (tryToJumpUp(num, bestState, nTimes))
                        cDirection = 'n';

                if (nTimes)
                    nCleanUpOnStep = bestState->nStep;
            }
            nFromLastCleanUp = bestState->number;
        }
    }

    delete bestState;                  // this is not java, we need to keep the memory clear.
    return str!=NULL;
}

char* positiveSpine = "nnnesssssessssssss";
char* negativeSpine = "esssssssseessssss";

bool canReachNumber(long long num, PChar& str, int& nLen, int& nScore)
{
    int nTimes = 0;
    botState tmpState;
    if ((num>=0) && (num<=20))
        return buildPath(num, str, nLen, nScore, &tmpState, nTimes);

    botState bestState;
    bestState.clone(&tmpState);

    char* spine = NULL;
    if (num>0)
    {
        spine = positiveSpine;
    }
    else
    {
        spine = negativeSpine;
    }

    for (int i=0; spine[i]; i++)
    {
        tmpState.nStep++;
        tmpState.path.push_back(spine[i]);
        if (!changeNumberWithDirection(tmpState.number, spine[i], tmpState.nStep))
            return false;

        if ((num>0) && (tmpState.number<num))
        {
            bestState.clone(&tmpState);
        }
        else if ((num<0) && (tmpState.number>num))
        {
            bestState.clone(&tmpState);
        }
    }

    if (bestState.number == num)
        return buildPath(num, str, nLen, nScore, &bestState, nTimes);

    botState tryPath;
    tmpState.clone(&bestState);
    for (int i=0; i<9; i++)
    {
        tryPath.clone(&tmpState);
        bool pathOK = true;
        for (int j=0; j<i; j++)
        {
            tryPath.nStep++;
            tryPath.path.push_back('e');
            if (!changeNumberWithDirection(tryPath.number, 'e', tryPath.nStep))
            {
                pathOK = false;
                break;
            }
        }
        tryPath.nStep++;
        tryPath.path.push_back('s');
        if (!changeNumberWithDirection(tryPath.number, 's', tryPath.nStep))
        {
            pathOK = false;
            break;
        }

        if ((pathOK) && (isBetterNum(tryPath.number, bestState.number, num)))
        {
            bestState.clone(&tryPath);
        }
    }

    // in case we'll need to add, but last step was south, move one to the east.
    if ((bestState.path.at(bestState.path.size()-1) == 's') && (bestState.number<num))
    {
        bestState.nStep++;
        bestState.path.push_back('e');
        if (!changeNumberWithDirection(bestState.number, 'e', bestState.nStep))
            return false;
    }

    if (bestState.number<num)
    {
        long long diff = num - bestState.number;
        diff/=45;
        nTimes = (int)diff*10;
        bestState.nStep += nTimes;
        bestState.path.push_back('*');
        bestState.number += 45*diff;
        while (num - bestState.number > 10)
        {
            bestState.nStep++;
            bestState.path.push_back('n');
            if (!changeNumberWithDirection(bestState.number, 'n', bestState.nStep))
                return false;
        }
        return buildPath(num, str, nLen, nScore, &bestState, nTimes);
    }
    else
    {
        long long diff = bestState.number - num;
        diff/=45;
        nTimes = (int)diff*10;
        bestState.nStep += nTimes;
        bestState.path.push_back('*');
        bestState.number -= 45*diff;
        while (bestState.number - num > 10)
        {
            bestState.nStep++;
            bestState.path.push_back('e');
            if (!changeNumberWithDirection(bestState.number, 'e', bestState.nStep))
                return false;
        }
        return buildPath(num, str, nLen, nScore, &bestState, -nTimes);
    }

    return false;
}
long long aVals[] = {49445094, 71259604, 78284689, 163586986, 171769219, 211267178, 222235492, 249062828, 252588742, 263068669, 265657839, 328787447, 344081398, 363100288, 363644732, 372642304, 374776630, 377945535, 407245889, 467229432, 480714605, 491955034, 522126455, 532351066, 542740616, 560336635, 563636122, 606291383, 621761054, 648274119, 738259135, 738287367, 748624287, 753996071, 788868538, 801184363, 807723631, 824127368, 824182796, 833123975, 849666906, 854952292, 879834610, 890418072, 917604533, 932425141, 956158605, 957816726, 981534928, 987717553};

void main(void)
{
    upperLimit =     2147483647;       //  2^31 - 1
    lowerLimit =-1;       // -2^31
    lowerLimit *=2147483648;       // -2^31
    long long num=0;
    char* str=NULL;
    int nLen = 0;
    int nItems = sizeof(aVals)/sizeof(aVals[0]);
    int nScore = 0;
    long long nTotalScore = 0;
//  nItems=1;

    for(int i=0; i<nItems; i++)
    {
        if (canReachNumber(aVals[i], str, nLen, nScore))  //try to reach it
        {
            printf("%3d) to reach %10lld, it takes %9d steps, by doing: %s\n", i, aVals[i], nScore, str);

            nTotalScore+=nScore;
            delete str;
        }
        else
        {
            if (aVals[i]>0)
                printf("Failed to reach %lld, use nenenenenenen..... ('n', followed by %lld pairs of 'en')\n", aVals[i], aVals[i]-1);
            else
                printf("Failed to reach %lld, use enenenenenene..... ('e', followed by %lld pairs of 'ne')\n", aVals[i], aVals[i]-1);
            nTotalScore+=2*aVals[i]-1;
        }
    }

    printf("done, total score is %lld\n", nTotalScore);
    return;
}
— Eyal Lev
quelle
Sind Sie in esssssssseessssss sicher, dass die Variable nicht überläuft? Wenn v = 1 t = 1, bedeutet diese Zeichenfolge (1 * 2 * 3 * 4 * 5 * 6 * 7-8) * 1 * 2 * 3 * 4 * 5 usw. oder so
— ähnlich
@RosLuP das ist nicht -8. es ist eher so: ((-1) * (2 * 3 * 4 * 5 * 6 * 7 * 8 * 9) -0-1) * 2 * 3 * 4 * 5 * 6 * 7, was -1828920240 ist Das ist ungefähr -2 ^ 30.7683, also geht es nicht vorbei -2 ^ 31
— Eyal Lev
2

Python, Score = 56068747912

def move(n):
    print("n" + "en" * (n - 1))

Druckt einfach nenenenenenenen...für jede Nummer.

Wird später eine Erklärung hinzufügen.

— Clismique
quelle
Um 1, nicht wahr? nenist 2
— edc65
@ edc65 Es wurde behoben.
— Clismique
Haben Sie diese Punktzahl erhalten, indem Sie diesen Code tatsächlich ausgeführt haben, oder ist dies Ihre "Vermutung", wenn alles richtig funktioniert?
— Eyal Lev
@EyalLev Letzteres. Es sollte sowieso wie erwartet funktionieren - jedes "en" nach dem anfänglichen "n" sollte den Wert um 1 erhöhen (da der Wert "-2 + 3-4 + 5 ...- 0 + 1-2 + 3" lautet). nach dem Anfangsbuchstaben "+1").
— Clismique
Das Problem ist, dass die Anforderung ist, dass es 10 Minuten dauert. Ich bin mir nicht sicher, ob Ihre Methode "Alle drucken lassen" diese Einschränkung erfüllt.
— Eyal Lev
2

Rost , Punktzahl = 1758 (optimal unter Wegen ohne Westen)

Läuft in insgesamt etwa 7 Sekunden für 50 Zahlen mithilfe einer bidirektionalen Suche .

use std::collections::HashSet;
use std::io::{self, prelude::*};

#[derive(Debug, Eq, Clone, Copy, Hash, Ord, PartialEq, PartialOrd)]
enum Dir {
    N,
    E,
    S,
}
use Dir::{E, N, S};

fn dir_char(dir: Dir) -> char {
    match dir {
        N => 'n',
        E => 'e',
        S => 's',
    }
}

#[derive(Debug, Eq, Clone, Hash, Ord, PartialEq, PartialOrd)]
struct State {
    counter: i32,
    value: i32,
    next: Dir,
}

fn step(s: &State) -> impl Iterator<Item = State> {
    let (values, nexts): (_, &[Dir]) = match s.next {
        N => (s.value.checked_add(s.counter), &[N, E]),
        E => (s.value.checked_sub(s.counter), &[N, E, S]),
        S => (
            if s.counter != 0 {
                s.value.checked_mul(s.counter)
            } else {
                None
            },
            &[E, S],
        ),
    };
    let counter = (s.counter + 1) % 10;
    values.into_iter().flat_map(move |value| {
        nexts.iter().map(move |&next| State {
            counter,
            value,
            next,
        })
    })
}

fn unstep(s: &State) -> impl Iterator<Item = State> {
    let counter = (s.counter + 9) % 10;
    (match s.next {
        N | E => s.value.checked_sub(counter).map(|value| State {
            counter,
            value,
            next: N,
        }),
        _ => None,
    }).into_iter()
        .chain(s.value.checked_add(counter).map(|value| State {
            counter,
            value,
            next: E,
        }))
        .chain(match s.next {
            E | S if counter != 0 && s.value % counter == 0 => {
                s.value.checked_div(counter).map(|value| State {
                    counter,
                    value,
                    next: S,
                })
            }
            _ => None,
        })
}

fn search(value: i32) -> String {
    let mut lefts: Vec<HashSet<State>> = Vec::new();
    let mut left = [N, E, S]
        .iter()
        .map(|&next| State {
            counter: 1,
            value: 0,
            next,
        })
        .collect::<HashSet<_>>();
    let mut rights: Vec<HashSet<State>> = Vec::new();
    let mut right = (0..10)
        .map(|counter| State {
            counter,
            value,
            next: E,
        })
        .collect::<HashSet<_>>();
    loop {
        if let Some(mid) = left.intersection(&right).min() {
            let mut path = Vec::new();
            let mut mid1 = mid.clone();
            for left in lefts.into_iter().rev() {
                let mid2 = unstep(&mid1)
                    .filter(|mid2| left.contains(mid2))
                    .next()
                    .unwrap();
                mid1 = mid2;
                path.push(mid1.next);
            }
            path.reverse();
            let mut mid1 = mid.clone();
            for right in rights.into_iter().rev() {
                let mid2 = step(&mid1)
                    .filter(|mid2| right.contains(mid2))
                    .next()
                    .unwrap();
                path.push(mid1.next);
                mid1 = mid2;
            }
            return path.into_iter().map(dir_char).collect::<String>();
        }
        if left.len() <= right.len() {
            let left1 = left.iter().flat_map(step).collect::<HashSet<_>>();
            lefts.push(left);
            left = left1;
        } else {
            let right1 = right.iter().flat_map(unstep).collect::<HashSet<_>>();
            rights.push(right);
            right = right1;
        }
    }
}

fn main() {
    let stdin = io::stdin();
    let values = stdin
        .lock()
        .lines()
        .flat_map(|line| {
            line.unwrap()
                .split(", ")
                .map(|s| s.parse().unwrap())
                .collect::<Vec<i32>>()
        })
        .collect::<Vec<_>>();

    for value in values {
        println!("{} {}", value, search(value));
    }
}

Probieren Sie es online aus!

Ausgabe

49445094 nennesseseenenesseseeseseeeeseess
71259604 nnnnnnessennnessseeesssenesenesses
78284689 ennnesssseeeneenesenesssseeesese
163586986 ennnesesseneeeeessennesseeseseeneesen
171769219 ennnessenessssessseesesseeseenesee
211267178 sennnnneseeenessssenessssenenneseseee
222235492 ennnnnesseeeneseesseeesseseneesseesee
249062828 nnnnnesseneneseesssenennesseenesse
252588742 nennnessenneeeessesesesseseeseseeseee
263068669 nennnesseessseeessseesseeenesesssen
265657839 nnnesssseneesesssennneenesseeeses
328787447 eennnesssenesseesssesennnneeseenese
344081398 sennnnesennnesesessesesssseeseennnn
363100288 sennnnesseeneseesssenneesessennenee
363644732 nnnesssenneessesseeesseseseesenees
372642304 nnnnesseneseneseesseneneesssennesese
374776630 sennnnesseseesseneseeeseseessenesen
377945535 nnnesssseneeennesseesseeessseeses
407245889 nnnesseneesessseseseeeeessessenenee
467229432 nnnnesesennnnnesessesessesseeneess
480714605 nnnnessennneseesssenenesenesseesesen
491955034 nnnnnessseeneeeessseeeseenesseseeee
522126455 nnnnesssseeneeesesseesesseeeenese
532351066 nennnessenneeenesesesesessessesenesen
542740616 sennnnesseeneenesssesseenesseesesesen
560336635 nnnesssesesesssseeennessseseeneee
563636122 sennnnnesennneseseennesesssesenesenes
606291383 nnnessssenneeeseseseeseseeeeseesese
621761054 nnnessseennessesssenneeseseseess
648274119 nnnnessseneesseseeseenessseeneseeese
738259135 eennnnnesenennnesseneessssssennnees
738287367 nnnessesseessseseseneeesesseennen
748624287 nennnesseesseeenneseessseseeseneseseese
753996071 nnnnessseneeeseesssenesesenennnesesen
788868538 nnnessesseeseeeneeseesesseesseseeseee
801184363 ennnesseseeseeeeseseeeeseeseseessse
807723631 nnnessessessssesseennnnesssen
824127368 nnnnessesenessseseennnessseesesennnnn
824182796 nnnnessesenesssseenesssesssenesee
833123975 ennnnnneseeeennnessesssessseennnneeesse
849666906 sennnessseeeeseesesesssenesseneeeesen
854952292 nnnnnnesenenesssseeneeessessseseeeeeeee
879834610 nennnnesseessseneeseeesessseseneee
890418072 nnnesssennnnessesesennnesessennnnees
917604533 ennnnesseneeseeesesenennesesseeneesse
932425141 ennnnesssesseesesenesssessseeneesen
956158605 nnnnesseseeeeesesssennneseseenesseee
957816726 enennnesseseeseesseessessssenesss
981534928 eennnessennessseesseesessseenessseenn
987717553 nnnessseeneeesssesseesssesennessee
— Anders Kaseorg
quelle
Man kann nie so jeder zu einer Zelle zurückkehren ns, sn, ewund weist sofort illegal zusätzlich zu Schleifen im Weg
— Veskah
@ Veskah Danke, dass du darauf hingewiesen hast. Feste von Verbieten w, nsund sn, die Blätter nur legale Wege auf Kosten des Ignorierens Rechtswege mit w.
— Anders Kaseorg
0

PHP, Score = 1391462099

function manoeuvre($n){
  $i=0;
  $c=0;
  $char='';
  while($i!=$n){
    $c=($c+1)%10;
    if($char!='n' and $c>0 and $i>0 and $i*$c<=$n){
      $char='s';
      $i=$i*$c;
    }
    else if($char!='s' and $i+$c<=$n and ($i-$c<=0 or ($i-$c)*max(($c+1)%10,2)>$n or $c==9)){
      $char='n';
      $i=$i+$c;
    }
    else{
      $char='e';
      $i=$i-$c;
    }
    echo $char;
  }
}

Ein schneller Versuch, geht niemals nach Westen, um die Pfadprüfung zu vereinfachen, und hat nur wenige Regeln, um bei jedem Schritt die Richtung zu bestimmen.

— Löwe
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.