99 è un linguaggio di programmazione che ho inventato all'inizio di questa settimana per la mia sfida Scrivi un interprete per 99 . (Inventato ma non è mai stato necessario implementarlo grazie a una mezza dozzina di voi.;)) Le specifiche linguistiche complete sono in quella sfida, quindi non mi preoccupo di ripubblicare tutto qui.

In 99 è possibile stampare singoli caratteri ASCII su stdout, ma a causa dei vincoli della lingua, non è sempre chiaro come stampare un determinato carattere nel modo più conciso possibile.

Per ciascuno dei 128 caratteri ASCII, scrivi un programma 99 che non accetta input e genera quel solo carattere. Puoi codificare una o tutte queste risposte a mano, oppure puoi scrivere un altro programma (in qualsiasi lingua che ti piace) per generarle per te.

La somma dei personaggi in ciascuno dei tuoi 128 99 programmi è il tuo punteggio. Vince il punteggio più basso. Newline conta come un personaggio.

Ricorda, in 99 , solo variabili di dimensioni pari come 9999caratteri ASCII di output (variabili di dimensioni dispari output interi). Il loro valore è diviso per 9 e quindi preso mod 128, quindi i valori non devono essere in un certo intervallo per mappare a caratteri ASCII. Ad esempio, i valori interni 297, 1449 e -855 corrispondono tutti al carattere !perché quando sono divisi per 9 e presi mod 128, diventano tutti 33, che è il codice carattere per !.

Se hai bisogno di un interprete per 99 , suggerirei la risposta Python di Mac .

^{So di aver detto che la mia prossima sfida sarebbe stata più interattiva, ma sto ancora lavorando sulle cose per quella.}

Un incarico, 2075 (ottimale)

Questo dovrebbe essere il valore ottimale (a meno che non abbia un grosso errore nel ragionamento o il mio test fa schifo).

Prima di tutto. Esistono solo 7 numeri diversi (mod 128) che puoi esprimere in 99. Tutti i valori di 7 o più 9 vengono valutati con lo stesso numero 71. (Poiché 10 ^ 8 mod 128 == 0, 10 ^ 9 mod 128 == 0, ...)

Se uno dei 4 valori che puoi esprimere con un numero pari di nove, che l'output di questo numero è chiaramente la soluzione ottimale.

Altrimenti cerco di raggiungere il numero con un'istruzione di assegnazione (assegnare a 99) e stampare 99. Come risulta, la dimensione massima del programma con questo approccio è di 22 caratteri. Chiaramente usare Goto richiede decisamente di più. L'unica possibilità che una soluzione a un compito possa essere battuta è una soluzione con due compiti. Ho provato questo (si spera senza errori, il codice per questo è abbastanza disordinato) e non ho trovato alcuna soluzione per qualsiasi carattere ASCII.

Pertanto, solo il controllo dei 4 numeri diretti e l'approccio con un compito dovrebbe essere sufficiente per trovare la soluzione ottimale. Il seguente programma Python (compatibile 2 e 3) genera tutti i programmi e ne riassume le lunghezze. Utilizza un semplice approccio IDA *.

from itertools import count

def nines_to_dec(nines):
    return ((10**nines - 1) // 9) % 128

def shortest_representation(ascii_value):
    # try simple output,
    # max code length is 8, (8 nines == 10 nines == 12 nines == ...)
    # if this works, than this is the shortest representation

    for nines in range(2, 9, 2):
        if nines_to_dec(nines) == ascii_value:
            return "9" * nines

    # otherwise try one assignment
    for length in count(1):
        result = assignment(ascii_value, length, [])
        if result:
            return "99 " + result + "\n99"

def assignment(value, left, nines_list):
    if left == 0:
        eval_numbers = [nines_to_dec(nines) for nines in nines_list]

        if (sum(eval_numbers[::2]) - sum(eval_numbers[1::2])) % 128 == value:
            return " ".join("9" * nines for nines in nines_list)
        else:
            return False

    for nines in range(1, 8):
        left2 = left - nines - 1 # -1 for space
        if left2 >= 0:
            result = assignment(value, left2, nines_list + [nines])
            if result:
                return result

    return False

lengths = []
for i in range(128):
    program =shortest_representation(i)
    lengths.append(len(program))
    print("ASCII-value: {}, ASCII-char: {}".format(i, chr(i)))
    print(program)

print(sorted(lengths))
print(sum(lengths))

L'output ha la forma seguente:

....
ASCII-value: 65, ASCII-char: A
99 9 999999 9999999
99
ASCII-value: 66, ASCII-char: B
99 9 99 9999 99
99
ASCII-value: 67, ASCII-char: C
99 9 99 9 99 9999
99
....

Puoi trovare l'output completo su: http://pastebin.com/bKXLAArq

Il carattere con il programma più breve (2 caratteri) ha vertical tab - 11una durata del programma di 2, i caratteri con i programmi più lunghi (22 caratteri) sono bell - 7e A - 65.

La somma per tutti i programmi è 2075.

E comunque, ho usato l' interprete k / q di tmartin . Odio alcuni problemi con gli altri (Python, Perl, CJam). Non sono sicuro che sia stata colpa mia.

Varie tecniche, 42109

Per i numeri, invece di calcolare il grande carattere ASCII, ho appena calcolato il valore del numero. Hai solo detto di essere in grado di produrre il personaggio, quindi dovrebbe funzionare ancora.

EDIT: cambiato i numeri per usare i caratteri ASCII, quindi ignoralo. Ho lasciato il codice numerico originale nel codice Java ma ho commentato nel caso in cui qualcuno volesse usarlo.

Alcuni di questi l'ho fatto a mano, la maggior parte ho appena scritto un programma per scrivere.

Sono composti da 1-4 righe ciascuno, quindi sono abbastanza facili da copiare e incollare in un programma. Va notato che non funzionano in successione a causa del mio codice generato che non conserva gli stati variabili.

La tecnica più comune usata qui era la stessa dell'approccio di orlp:

Continua a sottrarre 9 da 99, quindi emetti.

La mia versione differisce usando alcuni casi personalizzati e componendo molta della matematica su una sola riga. I casi personalizzati sono proprio dove il personaggio può essere rappresentato con solo un gruppo di 9 e nessun codice matematico o di generazione può essere abbreviato.

programmi

Ho messo l'output su Pastebin per quelli di voi che non hanno voglia di eseguire il programma:

http://pastebin.com/Cs6WZUfb

Codice Java che ho usato:

public class AsciiGen99 {

  public static void main(String[] args) {
    long totalsize = 0;
    for (int i = 0; i < 128; i++) {
      System.out.println("\n The program for ASCII code " + i + " is as follows:\n");
      String yea = find(i);
      if (yea != null) {
        System.out.println(yea);
        totalsize += yea.length();
      } else {
        String v = "99 9 9\n9 99 9";
        if (i != 0) {
          v += "\n99";
          for (int j = 0; j < i; j++) {
            v += " 99 9";
          }
        }

        v += "\n99";

        System.out.println(v);
        totalsize += v.length();
      }
    }
    System.out.println(totalsize);
  }

  public static String find(int i) {
    switch (i) {
      case '\0':
        return "99 9 9\n99";
      case '\1':
        return "99 9\n99";
    }
//    if (48 <= i && i <= 57) {
//      switch (i) {
//        case '0':
//          return "9 9 9\n9";
//        case '1':
//          return "9";
//        case '2':
//          return "999 9 9\n9 999 9\n999 999 9 999 9\n999";
//        case '3':
//          return "999 9 9\n9 999 9\n999 999 9 999 9 999 9\n999";
//        case '4':
//          return "999 9 9\n9 999 9\n999 999 9 999 9 999 9 999 9\n999";
//        case '5':
//          return "999 9 9\n9 999 9\n999 999 9 999 9 999 9 999 9 999 9\n999";
//        case '6':
//          return "99 9 9\n9 99 9\n999 99 9 99 9 99 9 99 9 99 9 99 9\n999";
//        case '7':
//          return "99 9 9\n9 99 9\n999 99 9 99 9 99 9 99 9 99 9 99 9 99 9\n999";
//        case '8':
//          return "99 9 9\n9 99 9\n999 99 9 99 9 99 9 99 9 99 9 99 9 99 9 99 9\n999";
//        case '9'://ironic
//          return "99 9 9\n9 99 9\n999 99 9 99 9 99 9 99 9 99 9 99 9 99 9 99 9 99 9\n999";
//      }
//    }
    int x, a;
    for (x = 0; x < 100000; x++) {
      a = i + 128 * x;
      String s = "" + a*9;
      if (containsOnly9(s) && (s.length() & 1) == 0) {
        return ("" + (a * 9));
      }
    }

    return null;
  }
  public static boolean containsOnly9(String s) {
    for (char c : s.toCharArray()) {
      if (c != '9' && c != ' ' && c != '\n' && c != '\r' && c != '\t') {
        return false;
      }
    }
    return true;
  }
}

Sottrazione ripetuta, 65280

Una soluzione banale da confrontare. Continua a sottrarre 9 da 99, quindi emetti. Esempio per il carattere ASCII 10:

99 99 9
99

Ci sono 128 programmi. Il primo programma è lungo due caratteri (99), ciascuno dopo 8 caratteri (99 99 9 \ n) più lungo del precedente.

Programma Python che genera programmi separati da righe vuote e punteggio di calcolo:

score = 0
for n in range(128):
    program = "99 99 9\n" * n + "99"
    score += len(program)
    print(program + "\n")

print(score)