Ihre Aufgabe ist es, 0-9anhand eines quadratischen Ziffernrasters ( ) eine der Möglichkeiten auszugeben, mit denen die Ziffern so gruppiert werden können, dass:

1. Jede Ziffer gehört zu genau einer Gruppe
2. Alle Gruppen haben die gleiche Anzahl von Ziffern
3. Alle Gruppen sind durch eine polygonartige Form begrenzt (dies bedeutet, dass jede Ziffer in der Gruppe neben [links, rechts, oben, unten] mindestens eine weitere Ziffer derselben Gruppe steht, es sei denn, jede Gruppe verfügt über 1 Element).
4. Alle Gruppen haben die gleiche Summe

Das Eingaberaster ist immer ein Quadrat: Sie können eine beliebige Eingabemethode auswählen (einschließlich der Angabe von Argumenten für eine Funktion oder Methode). Zusätzlich liefert der Eingang die Anzahl der Gruppen, in denen Ihr Programm die Ziffern gruppieren soll.

Beispiel Eingabe:

Angenommen, Ihr Eingabeformat ist stringOfDigits numberOfGroups .

Ein Beispiel für eine Eingabe wäre:

156790809 3

was sich in (ein Gitter aus sqrt(9) * sqrt(9)) übersetzen würde

1 5 6
7 9 0
8 0 9

Die müssten Sie in 3 Gruppen aufteilen, von denen jede 9 / 3 = 3Elemente mit der gleichen Summe haben sollte.

Ausgabe: Die Ausgabe sollte eine Ziffernfolge mit optionalen Leerzeichen und Zeilenumbrüchen für die Formatierung sein, wobei jeder Ziffer ein Buchstabe folgt a-z, der die Gruppe angibt. numberOfTotalDigits / numberOfGroupsIn jeder Gruppe sollten genau Elemente vorhanden sein. Sie müssen niemals etwas in mehr als 26 Gruppen aufteilen.

Beispielausgabe:

1a 5a 6b
7c 9a 0b
8c 0c 9b

Beachten Sie, dass das Ersetzen aller as durch bs und bs durch as gleichermaßen gültig ist. Solange jede Gruppe mit einem eigenen Buchstaben gekennzeichnet ist, ist die Ausgabe gültig.

Außerdem erwarte ich, dass die meisten Programme etwas in dieser Richtung ausgeben, da Zeilenumbrüche / Leerzeichen optional sind:

1a5a6b7c9a0b8c0c9b

In diesem Fall wird die Addition aller Ziffern der Gruppe a, boder cmacht 15. Darüber hinaus werden alle Gruppen durch ein Polygon gebunden.

Ungültige Ausgaben:

1a 5a 6b
7c 9a 0c
8c 0b 9b

weil die gruppen keine polygone bilden (genauer gesagt, die 6bsind isoliert und 0cauch einsam).

1a 5a 6b
7c 9a 0b
8c 0b 9b

weil die Gruppe b4 Elemente hat, während cnur 2.

Etc.

Wenn es keine gültige Lösung gibt, kann Ihr Programm alles tun (z. B. anhalten, abstürzen, für immer ausführen), aber wenn Ihr Programm druckt, Nonewenn es keine gültige Lösung gibt -15, wird dies Ihrem Ergebnis gerecht.

Wenn es mehr als eine Lösung gibt, müssen Sie nur eine drucken, aber -20wenn Ihr Programm alle durch ein Trennzeichen voneinander getrennt druckt.

Dies ist Codegolf, also gewinnt der kürzeste Code (mit Boni)!

Pyth , 122-20-15 = 87

=Z/lzQ=ks^lz.5Jm]dUzL[-bk+bk?tb%bkb?hb%hbkb)FNJIgNZB~Jm+NksmybN;|jbS{msm+@zk@S*Z<GQxsdkUzfqSsTUz^fqsmv@*ZzbY/smvdzQJQ"None

Änderungen:

• 130 -> 120: Auf durch Zeilenumbruch getrennten Eingang umgeschaltet.

• 120 -> 134: Ein Fehler mit Gruppen, deren Größe nicht der Seitenlänge der Matrix entsprach, wurde behoben.

• 134 -> 120: Druckt alle Lösungen, einschließlich der unter Gruppenumbenennung gleichwertigen.

• 120 -> 122: Es wurde ein Fehler behoben, bei dem anstelle aller legalen Gruppen nur Pfade generiert wurden.

Testlauf:

pyth programs/sum_group.pyth <<< '156790809
3'
1a5a6b7c9a0b8c0c9b
1a5a6c7b9a0c8b0b9c
1b5b6a7c9b0a8c0c9a
1b5b6c7a9b0c8a0a9c
1c5c6a7b9c0a8b0b9a
1c5c6b7a9c0b8a0a9b


pyth programs/sum_group.pyth <<< '156790808
3'
None

pyth programs/sum_group.pyth <<< '1111     
2'
1a1a1b1b
1a1b1a1b
1b1a1b1a
1b1b1a1a

Erläuterung:

Pyth code           (Pseudo)-Python code              Comments

(implicit)          z = input()                       z is the digit string
(implicit)          Q = eval(input())                 S is the number of groups
(implicit)          G = 'abcdefghijklmnopqrstuvwxyz'
=Z/lzQ              Z = len(z)/Q                      Z is the size of each group.
=ks^lz.5            k = int(len(z) ** .5)             k is the side length of the matrix.
Jm]dUz              J = map(lambda d:[d], range(len(z))) Locations are encoded as numbers.
L                   def y(b): return                  y will be the transition function.
 [-bQ                         [b-k,                   Move up - the row above is k less.
  +bQ                          b+k,                   Move down - the row below is k more.
  ?tb%bkb                      b-1 if b%k else b      Move left, unless at the left edge.
  ?hb%hbkb)                    b+1 if (b+1)%k else b] Move right, unless at right edge.
FNJ                 for N in J:                       This constructs the list of all
   IgNZB                       if N[Z-1]: break       Z-length connected groups.
   ~Jm+Nk                      J+=map(lambda k: N+[k],  Append to J the group of N +
      smybN                          sum(map(lambda b:  anything reachable from
                                     y(b),N)))        anywhere in N.
   ;                (end for)
|                   or                                Print first truthy thing between
 S{                 sorted(set(                       Unique elements in sorted order of
   ms               map(lambda b:sum(                 Map+sum over allowable combinations
     m+@zd          map(lambda d:z[d]+                Character in original digit string
       @S*Z<GQ      sorted(G[:Q]*Z)[                  Repeated and sorted early alphabet
        xsbd        sum(b).index(d)],                 At index of number in sum of groups
      Uz                range(len(z)))                Over possible indexes.
   f                filter(lambda T:                  To generate allowable combinations, 
                                                      we will filter all groups of Q paths.
    qSsTUz          sorted(sum(T)) == range(len(z))   Ensure all locations are visited.
    ^                                                 Combinations of
     f              filter(lambda Y:                  Filter over connected Z-length groups
      qsm           equal(sum(map(lambda k:           Sum of the values of the group
         v@*ZzkY    eval((z*Z)[k]),Y)                 In the original digit string
       /smvbzQ      sum(map(lambda b:eval(b),z))/Q    must equal the sum of all values in z
                                                      divided by the number of groups.
      J             J                                 Filter over connected Z-length groups
     Q              Q                                 Combinations of length Q
 "None              "None"                            If the above was empty, print "None"

JavaScript (ES6) 361 (376-15) 372

(Vielleicht kann man noch ein bisschen mehr golfen)

Als Funktion ist der erste Parameter die Ziffernfolge und der zweite Parameter die Anzahl der Gruppen.
Es ist eine naive rekursive Suche, die bei der ersten gefundenen Lösung stoppt (kein Bonus von -20).
Benötigen Sie weitere Testfälle, um die Leistung bei größeren Eingaben zu überprüfen.

F=(g,n,l=g.length,i=w=Math.sqrt(l),o=s=h='',
  R=(g,p,k,j=l/n,t=s/n,v=0,h=String.fromCharCode(97+k))=>(
    t-=g[p],!(t<0)&&(
      g=[...g],g[p]=h,
      S=f=>g.some((c,p)=>c<':'&&f(p)),
      --j?S(p=>(g[p+1]==h|g[p-1]==h|g[p+w+1]==h|g[p-w-1]==h)?v=R(g,p,k,j,t):0)
      :t?0:k?S(p=>v=R(g,p,k-1)):v=g
    ),v
  )
)=>([for(c of g)(s-=-c,h+=--i?c:(i=w,c+':'))],h=R(g=h,-1,n,1))?h.map((c,p)=>o+=c!=':'?g[p]+c:'')&&o:'None'

Ungolfed & Erklärt

F=(g,n)=> 
{
  var l = g.length, // string size, group size is l/n 
      w = Math.sqrt(l), // width of grid
      s,i,h,o;

  // Build a new string in h, adding rows delimiters that will act as boundary markers  
  // At the same time calculate the total sum of all digits
  h='',  // Init string
  s = 0, // Init sum 
  i = w, // Init running counter for delimiters
  [for(c of g)(
    s -= -c, // compute sum using minus to avoid string concatenation
    h += --i ? c : (i=w, c+':') // add current char + delimiter when needed
  )];


  // Recursive search
  // Paramaters:
  // g : current grid array, during search used digits are replaced with group letters
  // p : current position
  // k : current group id (start at n, decreaseing)
  // j : current group size, start at l/n decreasing, at 0 goto next group id
  // t : current group sum value, start at s/n decreasing

  var R=(g,p,k,j,t)=> 
  {
    var v = 0, // init value to return is 0
        h = String.fromCharCode(97+k); // group letter from group

    t-=g[p]; // subtract current digit

    if (t<0) // exceed the sum value, return 0 to stop search and backtrak
      return 0;

    g=[...g]; // build a new array from orginal parameter
    g[p] = h; // mark current position

    // Utility function  to scan grid array
    // call worker function  f only for digit elements
    //   skipping group markers, row delimieters and out of grid values (that are undefined)  
    // Using .some will return ealry if f returns truthy  
    var S=f=>g.some((c,p)=>c<':'&&f(p));

    if (--j) // decrement current group size, if 0 then group completed
    { // if not 0
      // Scan grid to find cells adiacent to current group and call R for each 
      S( p => {
        if (g[p+1]==h|g[p-1]==h|g[p+w+1]==h|g[p-w-1]==h) // check if adiacent to a mark valued h
        {
          return v=R(g,p,k,j,t) // set v value and returns it
        }
      })
      // here v could be 0 or a full grid 
    }
    else
    {
      // special case: at first call, t is be NaN because p -1 (outside the grid)
      // to start a full grid serach
      if (t) // check if current reached 0
        return 0; // if not, return 0 to stop search and backtrak


      if (k) // check if current group completed
      {
        // if not at last group, recursive call to R to check next group 
        S( p => {
          // exec the call for each valid cell still in grid
          // params j and t start again at init values
          return v=R(g,p,k-1,l/n,s/n) // set value v and returns it
        })
        // here v could be 0 or a full grid 
      }
      else
      {
        return g; // all groups checked, search OK, return grid with all groups marked
      }
    }
    return v
  };
  g = h; // set g = h, so g has the row boundaries and all the digits

  h=R(h,-1,n,1); // first call with position -1 to and group size 1 to start a full grid search

  if (h) // h is the grid with group marked if search ok, else h is 0
  {
    o = ''; // init output string
    // build output string merging the group marks in h and the original digits in g
    h.map( (c,p) => o += c>':' ? g[p]+c: '') // cut delimiter ':'
    return o;
  }
  return 'None';
}

Test In FireFox / Firebug - Konsole

F("156790809",3) Ausgabe 1c5c6b7a9c0b8a0a9b

F("156790819",3) Ausgabe None