Molti linguaggi di programmazione sono scritti usando solo ASCII, tab e newline stampabili. Questi 97 caratteri vengono quindi memorizzati in byte a 8 bit (che sono effettivamente in grado di contenere 256 caratteri diversi!), Il che è terribilmente inefficiente, specialmente nel golf del codice, dove ogni byte conta! In questa sfida, sarai in grado di ridurre il tuo punteggio utilizzando la conversione di base.

Sfida

Il tuo programma / funzione accetta una stringa o un array di caratteri come input, che poi interpreta come un numero base-97 . Quindi converte questo in un numero base-256 e conta il numero di simboli (cioè byte) necessari per rappresentare questo numero. Questo conteggio sarà il valore di output / return del tuo programma / funzione.

Un semplice esempio usando base-2 e base-10 (binario e decimale): se l'ingresso è 10110, l'output sarebbe 2, poiché 10110 ₂ = 22 ₁₀ (due cifre necessarie per rappresentare l'output). Allo stesso modo, 1101 ₂ diventa 13 ₁₀ , dando anche un output di 2, e 110 ₂ diventa 6 ₁₀ , quindi l'output sarebbe 1.

La stringa di input può contenere tutti i 95 caratteri ASCII stampabili, nonché una nuova riga \ne una scheda letterale \t, che crea un alfabeto di origine di 97 simboli per la conversione di base. L'alfabeto esatto sarà quindi (sostituendo la \te \ncon la scheda e la riga letterale effettive; notare lo spazio letterale seguendo la riga nuova) :

\t\n !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Si noti che l'ordine di questo alfabeto è importante: ad esempio, base-97 \tcorrisponde a decimale 0e !corrisponde a decimale 3.

Alcuni test: (non è necessario gestire una stringa vuota)

Input                             Output
'example@domain.com'                  15
'All your base are belong to us!'     26
'       abcd'                          9
'~      abcd'                         10
'ABCDEFGHIJK'                          9
'zyxwvutsrpq'                         10
'{".~"}.~'                             7
'\t\t\t\t\t\t\t\t'                     1 (with \t a literal tab; the result is 0, which can be represented with 1 byte)
'!\t\t\t\t\t\t\t\t'                    7 (with \t a literal tab)

punteggio

1. Se la tua voce utilizza solo ASCII, newline e / o tab stampabili: il punteggio del tuo programma sarà l'output del tuo programma, quando ti verrà dato il suo codice sorgente come input.

2. Se la tua voce utilizza caratteri non ASCII stampabili, newline o tab: il punteggio del tuo programma è semplicemente il numero di byte, come nel code-golf .

Python 2 , punteggio 73 72 71

Modifica: -1 grazie a @Jonathan Allan

def f(l,z=0):
	for i in map(ord,l):z+=i-[30,9][i<32];z*=97
	print(len(bin(z))-2)/8or 1

Provalo online!

Japt , punteggio 19 (23 byte)

nHo127 uA9 md)sG l /2 c

Provalo online!

Per coincidenza, non penso che questo possa essere giocato molto anche con caratteri non ASCII ...

Spiegazione

UnHo127 uA9 md)sG l /2 c   Implicit: U = input string, A = 10, G = 16, H = 32
  Ho127                    Create the range [32, 33, ..., 126].
        uA9                Insert 9 and 10 at the beginning of this range.
            md             Map each to a character, yielding ["\t", "\n", " ", "!", ... "~"].
Un            )            Convert U to a number via this alphabet ("\t" -> 0, "~" -> 96, etc.)
               sG          Convert this number to a base-16 (hexadecimal) string.
                  l        Take the length of this string.
                    /2 c   Divide by two and round up to get the length in base-256.
                           Implicit: output result of last expression

Jelly ,  18  17 byte - punteggio  18  17

-1 byte grazie a Erik the Outgolfer (non è necessario un elenco di elenchi per la traduzione)

O“µœ½þ‘y_30ḅ97b⁹L

Provalo online!

Come?

O“µœ½þ‘y_30ḅ97b⁹L - Link: list of characters
O                 - convert from characters to ordinals
 “µœ½þ‘           - code-page indices = [9,30,10,31]
       y          - translate (9->30 and 10->31)
        _30       - subtract 30
           ḅ97    - convert from base 97
               ⁹  - literal 256
              b   - convert to base
                L - length of the result

- Il migliore che ho solo con ASCII è un punteggio di 29 :

O10,31,9,30y_30Ux"J_1 97*$$$SSb256L

- anche questo è estremamente inefficiente. Traduce gli ordinali come sopra, ma la conversione dalla base 97 si ottiene ripetendo i valori e la somma, piuttosto che usare la moltiplicazione diretta - cioè per convertire {".~"}.~ottiene gli indici regolati [93,4,16,96,4,95,16,96]quindi inverte ( U) e li ripete per fare [[96,96,..., 97⁷ times ...,96],[16,16,... 97⁶ times ...16],[95,95,... 97⁵ times ...95],[4,4,... 97⁴ times ...4],[96,96,... 97³ times ...96],,[16,16,... 97² times ...,16],[4,4,... 97 times ...4],[93]]e quindi sommare, converte in base 256 e ottiene la lunghezza (se non ha esaurito la memoria: p).

J , 36 byte, punteggio = 30

256#@(#.inv)97x#.(u:9,10,32+i.95)&i.

Provalo online!

J usa solo i caratteri ASCII a 7 bit per le sue primitive.

Spiegazione

256#@(#.inv)97x#.(u:9,10,32+i.95)&i.  Input: string S
                 (              )     Form 7-bit ASCII alphabet
                            i.95        Range [0, 95)
                         32+            Add 32
                    9,10,               Prepend 9 and 10
                  u:                    Convert to characters
                                 &i.  Index of each char in S in that alphabet
            97x#.                     Convert from base 97 to decimal
256   #.inv                           Convert to base 256
   #@                                 Length

Gaia , 14 byte, punteggio 14

9c₸c₵R]$;B₵rBl

Provalo online!

Spiegazione

9c              Push a tab character. (done like this since tab isn't in the codepage)
  ₸c            Push a linefeed character.
    ₵R          Push all printable ASCII characters.
      ]$        Concatenate everything together.
        ;       Copy second-from-top, implicitly push input. Stack is now [ASCII input ASCII]
         B      Convert input from the base where the ASCII string is the digits.
          ₵rB   Convert that to the base where the code page is the digits (base 256).
             l  Get the length of the result.
                Implicitly output top of stack.

Solo ASCII

Questo è il massimo che ho potuto inventare usando solo ASCII, ottenendo un punteggio di 19:

9c10c8373c'R+e]$;B256Bl

La difficoltà sta nella conversione dell'input. L'unico modo ragionevole per convertire dal sistema base-97 è usare B, poiché la mappatura richiede non ASCII ¦. Inoltre, al momento non esiste un modo per creare un intervallo di caratteri senza mappare cun intervallo di numeri, che presenta lo stesso problema. La migliore soluzione che ho potuto vedere è stata costruire la stringa ₵Re valutarla.

Python 2 , punteggio 60

lambda s:len(bin(reduce(lambda a,c:a*97+ord(c)-[30,9][c<' '],s,0)))+5>>3

Provalo online!

Mappatura su base-97

Il valore di un carattere è ottenuto da ord(c)-[30,9][c<' ']: il suo codice ASCII, meno 9 per le schede e le nuove righe (che precedono ' 'lessicograficamente) o meno 30 per tutto il resto.

Conversione in un numero

Usiamo reduceper convertire la stringa in un numero. Ciò equivale al calcolo

a = 0
for c in s: a = a*97+ord(c)-[30,9][c<' ']
return a

Lunghezza base 256 di calcolo

Il valore restituito da binè una stringa, che assomiglia in qualche modo a questo:

"0b10101100111100001101"

Chiama la sua lunghezza L. Un valore con una nrappresentazione binaria -bit ha una rappresentazione ceil(n/8)-bit base-256. Possiamo calcolare ncome L-2; inoltre, ceil(n/8)può essere scritto come floor((n+7)/8)= n+7>>3, quindi la nostra risposta è L-2+7>>3= L+5>>3.

Il caso in cui la stringa di input ha valore 0 viene gestito correttamente, come binrestituisce "0b0", quindi restituiamo 3+5>>3= 1.

APL, punteggio 24 (byte *)

⌈256⍟97⊥97|118|¯31+⎕AV⍳⍞

Presuppone il valore predefinito ⎕IO←1, altrimenti cambia ¯31 in ¯30.

Spiegazione:

                   ⎕AV⍳⍞  Read a string and convert it to ASCII codepoints + 1
               ¯31+       Subtract 31, so that space = 2, bang = 3, etc.
           118|           Modulo 118, so that tab = 97, newline = 98
        97|               Modulo 97, so that tab = 0, newline = 1
     97⊥                  Decode number from base 97
⌈256⍟                     Ceiling of log base 256, to count number of digits

Esempi:

      ⌈256⍟97⊥97|118|¯31+⎕AV⍳⍞
example@domain.com
15
      ⌈256⍟97⊥97|118|¯31+⎕AV⍳⍞
All your base are belong to us!
26
      ⌈256⍟97⊥97|118|¯31+⎕AV⍳⍞
       abcd
9
      ⌈256⍟97⊥97|118|¯31+⎕AV⍳⍞
~      abcd
10

^{________________
*: APL può essere scritto nel proprio set di caratteri legacy (definito da ⎕AV) anziché Unicode; pertanto un programma APL che utilizza solo caratteri ASCII e simboli APL può essere valutato come 1 carattere = 1 byte.}

Perl 5 , 76 + 1 (-F) = 77 byte

}{$d+=97**(@F+--$i)*((ord)-(/	|
/?9:30))for@F;say!$d||1+int((log$d)/log 256)

Provalo online!

Come?

Implicitamente, separa i caratteri dell'input ( -F), memorizzando tutto ciò in @F. Chiudi il whileciclo implicito e avvia un nuovo blocco ( }{) ( Grazie, @Dom Hastings! ). Per ogni personaggio, moltiplica il suo valore per 97 per la potenza appropriata. Calcola il numero di caratteri trovando la dimensione della somma nella base 256 usando i logaritmi.

Jelly , punteggio: 18 (byte)

9,⁷Ọ;ØṖiЀ⁸’ḅ97b⁹L

Provalo online!

Rubino , 70 byte, punteggio 58

->n{x=0;n.bytes{|i|x+=i-(i<32?9:30);x*=97};a=x.to_s(2).size/8;a<1?1:a}

Provalo online!

MATL (19 byte), punteggio 16

9=?1}G9tQ6Y2hh8WZan

I caratteri non stampabili (tab, newline) nella stringa di input vengono immessi contatenando i loro codici ASCII ( 9, 10) con il resto della stringa.

• Provalo online! ;
• Verifica tutti i casi di test ;
• Calcola il punteggio del programma .

La parte iniziale 9=?1}Gè necessaria solo a causa di un bug nella funzione Za(conversione di base), che provoca un errore quando l'input è costituito solo da "zeri" (schede qui). Sarà risolto nella prossima versione della lingua.

Spiegazione

9=      % Implicitly input a string. Compare each entry with 9 (tab)
?       % If all entries were 9
  1     %   Push 1. this will be the ouput
}       % Else
  G     %   Push input string again
  9     %   Push 9 (tab)
  tQ    %   Duplicate, add 1: pushes 10 (newline)
  6Y2   %   Push string of all printable ASCII chars
  hh    %   Concatenate twice. This gives the input alphabet of 97 chars
  8W    %   Push 2 raised to 8, that is, 256. This represents the output
        %   alphabet, interpreted as a range, for base conversion
  Za    %   Base conversion. Gives a vector of byte numbers
  n     %   Length of that vector
        % End (implicit). Display (implicit)

Befunge-93, 83 79 byte, punteggio 74 65

<v_v#-*52:_v#-9:_v#`0:~
 5v$
^6>>1>\"a"* +
 >*- ^   0$<
0_v#:/*4*88\+1\ $<
.@>$

Provalo qui!

Il programma prima converte l'input in un numero base-97, quindi conta quante cifre sono necessarie per un numero base-256. Come tale, il numero di base-97 è enorme, così grande che TIO produrrà un valore massimo di 8 per valori grandi; tuttavia, l'interprete JS non si preoccupa e produrrà il valore corretto.