Scrivi codice auto-validante


28

Scrivi il codice che accetta una stringa come input e genera un valore di verità o falsità a seconda che la stringa segua o meno queste regole:

Se impilate ogni personaggio uno sopra l'altro, convertitelo in binario e sommate ogni colonna, quindi tutte le somme dovrebbero essere identiche. Si può presumere che la stringa di input contenga solo caratteri ASCII stampabili (punti di codice 32 - 126).

Come esempio:

L'input O5vy_+~dovrebbe restituire un valore di verità, poiché la sua rappresentazione binaria è:

1001111  | O
0110101  | 5
1110110  | v
1111001  | y
1011111  | _
0101011  | +
1111110  | ~
-------
5555555  <- Sum of bits in each column. Should give a truthy value.

L'input PPCGdovrebbe restituire un valore false, poiché la sua rappresentazione binaria è:

1010000  | P
1010000  | P
1000011  | C
1000111  | G
-------
4020122  <- Should give a falsey value

Il colpo di scena è: il tuo codice dovrebbe restituire un valore veritiero se viene utilizzato come input per la tua funzione / programma. Vale a dire il codice deve rispettare le stesse regole di cui sopra (il codice può contenere caratteri che non sono ASCII 32-126).

Il tuo programma / funzione deve solo gestire ASCII stampabile come input. Se il tuo codice contiene qualcos'altro, codifica a 8 bit, 16 bit, Unicode, un set di caratteri su misura (o qualcos'altro), la sua rappresentazione binaria dovrebbe aderire alle stesse regole, ma il tuo codice non deve gestirlo come input.

Questo è , quindi si applicano le regole standard.


Quanto sarà lunga la stringa di input? Possiamo supporre che la somma sarà sempre lunga 7 cifre?
Okx,

Inoltre, se il nostro programma utilizza caratteri diversi dai caratteri ASCII, cosa succede?
Okx,

Immagino che "allora la sua rappresentazione binaria dovrebbe aderire alle stesse regole" dovrebbe escludere esplicitamente la clausola "deve solo gestire ASCII stampabile come input" (altrimenti si potrebbe scrivere un codice con un solo byte mappato su ASCII non stampabile) .
Jonathan Allan,

@Okx puoi supporre che la stringa di input sia inferiore a 1kB. L'input sarà solo ASCII stampabile che può essere rappresentato usando 7 bit, quindi sì: ci saranno sempre 7 somme intere (non necessariamente cifre).
Stewie Griffin,

2
@StewieGriffin Non è un ottimo chiarimento. Se ho una risposta non ASCII e provi a inserire il programma nel programma e non funziona perché supporta solo ASCII, cosa succede?
Okx,

Risposte:


10

JavaScript (ES6), 123 122 120 110 byte

S=>[...S].map(S=>R.map((_GSSSSSSVWWW,V)=>R[V]-=S.charCodeAt()>>V&1),R=[_=3^3,_,_,_,_,_,_])&&!R.some(S=>S^R[_])

Di seguito è riportato un hexdump con somme di bit.

Addr. | Dump                                            | #6 #5 #4 #3 #2 #1 #0
------+-------------------------------------------------+---------------------
00-0F | 53 3D 3E 5B 2E 2E 2E 53 5D 2E 6D 61 70 28 53 3D |  8 11  9 11  9  9  9
10-1F | 3E 52 2E 6D 61 70 28 28 5F 47 53 53 53 53 53 53 | 20 18 19 17 14 20 19
20-2F | 56 57 57 57 2C 56 29 3D 3E 52 5B 56 5D 2D 3D 53 | 30 24 32 25 26 30 29
30-3F | 2E 63 68 61 72 43 6F 64 65 41 74 28 29 3E 3E 56 | 41 37 37 32 34 38 36
40-4F | 26 31 29 2C 52 3D 5B 5F 3D 33 5E 33 2C 5F 2C 5F | 47 47 48 43 44 47 46
50-5F | 2C 5F 2C 5F 2C 5F 2C 5F 5D 29 26 26 21 52 2E 73 | 54 57 55 54 56 56 54
60-6D | 6F 6D 65 28 53 3D 3E 53 5E 52 5B 5F 5D 29       | 64 64 64 64 64 64 64

dimostrazione


10

MATL , 10 9 byte

BXs&=?I&]

L'input è una stringa racchiusa tra virgolette singole (se l'input contiene singoli qoutes, evitali duplicando).

L'output è 3 vero e nulla (output vuoto) come falso.

Provalo online!

Il codice in binario è il seguente:

B     1 0 0 0 0 1 0
X     1 0 1 1 0 0 0
s     1 1 1 0 0 1 1
&     0 1 0 0 1 1 0
=     0 1 1 1 1 0 1
?     0 1 1 1 1 1 1
I     1 0 0 1 0 0 1
&     0 1 0 0 1 1 0
]     1 0 1 1 1 0 1

Sum   5 5 5 5 5 5 5

Spiegazione

B      % Input string (implicit). Convert each char to its ASCII code, and 
       % then to binary. This gives a binary matrix, with each char of the 
       % input corresponding to a row
Xs     % Sum of each column. Gives a row vector
&=     % All pairwise equality comparisons
?      % If all are true
  I    %    Push 3
  &    %    Specify that the next function, namely implicit display, will 
       %    take one input, instead of the whole stack which is the default
]      % End
       % Display (implicit)

8

Gelatina , 11 10 byte

OBUSE&889.

Provalo online! Oppure vedi test e auto-input (il codice è tutto ASCII stampabile, che ha gli stessi valori nellatabella codici di Jelly, come mostrato di seguito).

Char -> Hex -> Decimal -> Binary
O       0x4F   79         0b1001111
B       0x42   66         0b1000010
U       0x55   85         0b1010101
S       0x53   83         0b1010011
E       0x45   69         0b1000101
&       0x26   38         0b0100110
8       0x38   56         0b0111000
8       0x38   56         0b0111000
9       0x39   57         0b0111001
.       0x2E   46         0b0101110
                            -------
                            5555555

Come?

OBUSE&889. - Main link: string
O          - cast to ordinals
 B         - convert to binary
  U        - upend (reverses each to prepare for vectorised sum)
   S       - sum (vectorises)
    E      - all equal? (yields 1 if all bit-sums are equal and 0 if not)
      889. - 889.0
     &     - bitwise and (1 & 889.0 is 1; and 0 & 889.0 is 0)

Il tuo codice assomiglia molto a quello di Dennis.
Erik the Outgolfer,

Sì, ho visto dopo.
Jonathan Allan,

6

Gelatina , 11 10 byte

OBUSE$*8?8

Non utilizza nessuna operazione o commento.

Provalo online!

Ripartizione binaria

O  1 0 0 1 1 1 1
B  1 0 0 0 0 1 0
U  1 0 1 0 1 0 1
S  1 0 1 0 0 1 1
E  1 0 0 0 1 0 1
$  0 1 0 0 1 0 0
*  0 1 0 1 0 1 0
8  0 1 1 1 0 0 0
?  0 1 1 1 1 1 1
8  0 1 1 1 0 0 0
————————————————
∑  5 5 5 5 5 5 5

Come funziona

OBUSE$*8?8  Main link. Argument: s (string)

O           Ordinal; map all characters in s to their code points.
 B          Binary; convert each code point to base 2.
  U         Upend; reverse each binary array to right-align the digits.
       8?   If 8 is non-zero (it is):
   SE$          Sum the corresponding digits and test the the sums for equality.
            Else (never happens):
      *  8      Raise all binary digits to the eighth power.

Jelly TC utilizza solo ASCII stampabile?
Pavel,

Io non la penso così.
Dennis,

1
Mi piace che questo codice inizi con OBUSEperché suona come ABUSE.
Esolanging Fruit,

4

Mathematica, 88 byte

Total@IntegerDigits[ToCharacterCode@#,2,7]~MatchQ~{"?";a_ ..}&

Contiene molti caratteri non stampabili tra virgolette. Ha 49 di ogni bit.

Ecco il hexdump:

0000-0010:  54 6f 74 61-6c 40 49 6e-74 65 67 65-72 44 69 67  Total@In tegerDig
0000-0020:  69 74 73 5b-54 6f 43 68-61 72 61 63-74 65 72 43  its[ToCh aracterC
0000-0030:  6f 64 65 40-23 2c 32 2c-37 5d 7e 4d-61 74 63 68  ode@#,2, 7]~Match
0000-0040:  51 7e 7b 22-3f 1f 1f 1f-1f 1f 1f 1f-1f 1f 1f 1f  Q~{"?... ........
0000-0050:  1f 1f 1f 1f-1f 1a 1a 1a-1a 18 18 18-18 18 10 22  ........ ......."
0000-0058:  3b 61 5f 20-2e 2e 7d 26                          ;a_...}&

4

Ottava, 53 52 byte

Fare una riscrittura completa mi ha aiutato a golfare il codice 5 byte, ma ho dovuto aggiungere più no-op, rendendolo un risparmio netto di solo 1 byte.

@(_)~diff(sum(de2bi(+_)))%RRPPPVVVW?????????________

Non riesco ad aggiungere un collegamento TIO, poiché nessuno degli interpreti online ha implementato la cassetta degli strumenti di comunicazione necessaria per de2bi. Modificandolo indec2bin invece costerebbe 4 byte (2 per il codice funzionante e due no-ops).

Non ho trovato alcun modo per evitare nessuna delle 27 operazioni vietate. Tutti i nomi delle funzioni e le parentesi sono tra 64 o inferiori a 96, il che significa che tutti i caratteri "necessari" hanno un 1 nella sesta posizione (da destra, 2 ^ 5). Avevo una soluzione con solo 23 no-op, ma il codice stesso era più lungo. Il codice effettivo è di 25 byte e ha la seguente somma di colonne quando si contano i bit dell'equivalente binario:

15   22    6   15   10    9   13

Vi sono 22 bit nella 6a posizione da destra (2 ^ 5) e solo 6 bit nella 4a posizione da destra (2 ^ 3). Ciò significa che dobbiamo aggiungere almeno 16 byte, per ottenere i 6 fino a 22. Ora, il carattere di commento %aggiunge un po 'alla sesta posizione, aumentandolo a 23. Tutti i caratteri ASCII stampabili richiedono almeno uno dei due i migliori pezzi da essere 1. Pertanto, l'aggiunta di 17 byte ci darà almeno 27 bit in ciascuno dei due "primi posti" (2 ^ 6 e 2 ^ 5). Ora, abbiamo 27 bit nei primi due punti e 22 nel resto. Per raggiungere un equilibrio, dobbiamo aggiungere 10 byte, per arrivare anche a 32 bit in ciascuna posizione.

Una spiegazione del nuovo codice (52 byte):

@(_)~diff(sum(de2bi(+_)))
@(_)      % An anonymous function that take a variable _ as input
          % We use underscore, instead of a character, since it has the
          % most suitable binary represetation
              de2bi(+_)    % Convert the input string to a binary matrix
          sum(de2bi(+_))   % Take the sum of each column
     diff(sum(de2bi(+_)))  % And calculate the difference between each sum
    ~diff(sum(de2bi(+_)))  % Negate the result, meaning 0 becomes true, 
                           % and everything else becomes false

Un vettore contenente solo 1s (vero) viene valutato come vero in Ottava e un vettore contenente almeno uno zero viene valutato come falso in Ottava.

Una spiegazione del vecchio codice (53 byte):

@(_)!((_=sum(de2bi(+_)))-_(1))%RRRFVVVVVVVVV_____????

@(_)      % An anonymous function that take a variable _ as input
          % We use underscore, instead of a character, since it has the
          % most suitable binary represetation
    !     % Negate the result, meaning 0 becomes true, and everything else becomes false
        de2bi(+_)         % Convert the input string to a binary matrix
    sum(de2bi(+_))        % Take the sum of each column
 (_=sum(de2bi(+_)))       % Assign the result to a new variable, also called _
                          % It's not a problem that we use the same variable name, due
                          % to the order of evaluation
((_=sum(de2bi(+_)))-_(1)) % Subtract the first element of the new variable _
                          % If all elements of the new variable _ are identical, then this
                          % should give us a vector containing only zeros,
                          % otherwise, at least one element should be non-zero
!((_=sum(de2bi(+_)))-_(1))  % And finally, we negate this.

Un vettore contenente solo 1s (vero) viene valutato come vero in Ottava e un vettore contenente almeno uno zero viene valutato come falso in Ottava.


3

JavaScript (ES6), 139 111 107 byte

f=
S=>![...""+1E6].some((____________ABQWWWWWWWWW,P)=>P*=R^(R^=R,[...S].map(Q=>R+=Q.charCodeAt()>>P&1),R),R=0)
<textarea oninput=o.textContent=f(this.value) style=width:100% rows=10>S=>![...""+1E6].some((____________ABQWWWWWWWWW,P)=>P*=R^(R^=R,[...S].map(Q=>R+=Q.charCodeAt()>>P&1),R),R=0)</textarea><div id=o>true

Contiene 81 63 61 di ogni bit.


2

Scala, 149 byte

_.map(C=>("0"*7++(BigInt(C)toString 2))takeRight 7 map(_-48)).transpose.map(_.sum).toSet.size==1//______________________________

Uso:

val f:(String=>Any)=_.map(C=>("0"*7++(BigInt(C)toString 2))takeRight 7 map(_-48)).transpose.map(_.sum).toSet.size==1//______________________________
println(f("string here")

hexdump:

00000000  5f 2e 6d 61 70 28 43 3d  3e 28 22 30 22 2a 37 2b  |_.map(C=>("0"*7+|
00000010  2b 28 42 69 67 49 6e 74  28 43 29 74 6f 53 74 72  |+(BigInt(C)toStr|
00000020  69 6e 67 20 32 29 29 74  61 6b 65 52 69 67 68 74  |ing 2))takeRight|
00000030  20 37 20 6d 61 70 28 5f  2d 34 38 29 29 2e 74 72  | 7 map(_-48)).tr|
00000040  61 6e 73 70 6f 73 65 2e  6d 61 70 28 5f 2e 73 75  |anspose.map(_.su|
00000050  6d 29 2e 74 6f 53 65 74  2e 73 69 7a 65 3d 3d 31  |m).toSet.size==1|
00000060  2f 2f 5f 5f 5f 5f 5f 5f  5f 5f 5f 5f 5f 5f 5f 5f  |//______________|
00000070  5f 5f 5f 5f 5f 5f 5f 5f  5f 5f 5f 5f 5f 5f 5f 5f  |________________|
00000080  1f 1f 1f 1f 1e 1e 1e 1e  16 16 16 16 16 12 12 10  |................|
00000090  10 10 10 10 10                                    |.....|

Ungolfed:

string =>
  string.map(char =>
    (
      "0" * 7 ++ BigInt(char).toString(2)
    ).takeRight(7).map(n=>n-48)
  ).transpose
  .map(bits=>bits.sum)
  .toSet
  .size == 1
  //______________________________

Spiegazione:

string =>                      //create an anonymous function with a parameter string
  string.map(char =>           //map each char in the string to
    (
      "0" * 7                  //a string of 7 zeroes
      ++                       //concatenated with
      BigInt(char).toString(2) //the ascii value as a binary string
    ).takeRight(7)             //the last 7 items from this sequence
    .map(n=>n-48)              //where each digit is mapped to its numerical value
  ).transpose                  //transpose, so the colums become rows and vice-versa
  .map(bits=>bits.sum)         //maps the bits in each column to their sum
  .toSet                       //and convert the sequence of sums to a set
  .size == 1                   //which has 1 element of the sums are the same
  //______________________________

1

J , 45 byte

[:(*/@:={.)[:+/2 #.inv 3 u:]NB.____UUUUUUUUDD

Provalo online! Include casi di test per la maggior parte degli invii inviati, insieme al codice sorgente.


1

Haskell , 118 byte

_R _S=mod _S 2:_R(div _S 2)
_Z _S|_V:_W<-take 7.foldl1(zipWith(+))$_R.fromEnum<$>_S=all(==_V)_W
--________

Provalo online! Utilizzo: _Z "some string"restituisce Trueo False.

Ci sono alcuni caratteri non stampabili nel commento sull'ultima riga, quindi ecco una stringa del programma che usa caratteri di escape:

"_R _S=mod _S 2:_R(div _S 2)\n_Z _S|_V:_W<-take 7.foldl1(zipWith(+))$_R.fromEnum<$>_S=all(==_V)_W\n--___\US\US\US\ETB\DC3\DC3\DC3\DC3\DC3\DC3\DC2\DC2_____"

Ogni bit si verifica 68 volte.


Il codice più corto che mi è venuto in mente era di 82 byte:

b n=mod n 2:b(div n 2)
(all=<<(==).head).take 7.foldl1(zipWith(+)).map(b.fromEnum)

Tuttavia, le somme dei bit per questo codice sono [33,28,41,48,20,79,46]così79 - 20 = 59 sarebbero necessarie ulteriori operazioni più 2 byte per l'avvio di un commento, per un totale di 143 byte.

Riorganizzando il programma ho scoperto che l'uso di lettere maiuscole come nomi di variabili aiuta a livellare le somme perché non hanno il bit nella sesta posizione impostata. Poiché Haskell non consente ai nomi di variabili di iniziare con una lettera maiuscola, devono essere anteposti _ , che inoltre non imposta il sesto bit.

In tal modo ho finito con la soluzione di cui sopra che ha 97 byte prima di aggiungere le no-op e la somma bist a [50,47,56,56,48,68,60], quindi (68 - 47) = 21, nel commento devono essere aggiunti solo 21 byte.


1

PHP, 95 93 91 byte

Sono così felice che i nomi delle funzioni PHP non fanno distinzione tra maiuscole e minuscole!

FOR(ZZSSSSQ__*;$W=ORD($argn[$T++]);)FOR($V=7;$V--;)$R[$V]+=$W>>$V&1;PRINT MIN($R)==MAX($R);

dove *deve essere sostituito con ASCII 151 (0x97). (PHP si lamenterebbe di qualsiasi carattere di controllo nel codice - a parte \re\n , ma ho bisogno di qualcosa con il bit 4 impostato, quindi ho aggiunto 128.)

+1 byte per ASCII stampabile puro: utilizzare _7 invece.

Esegui echo '<input>' | php -nR '<code>'o prova online . L'output è 1vero, vuoto per falso.


0

Python 2, 117 byte

Tutti gli "spazi" sono schede per ridurre il numero di 0x20 bit.

def Y(S):
    O=map(sorted,zip(*['{:07b}'.format(ord(W))for   W   in  S]))
    return  O[1:]==O[:-1]#V_____________

Contiene 66 di ogni bit. (Non c'è '%07b'come spiegato in questo numero .)

Discarica esadecimale:

00000000: 64 65 66 09 59 28 53 29 3a 0a 09 4f 3d 6d 61 70  def.Y(S):..O=map
00000010: 28 73 6f 72 74 65 64 2c 7a 69 70 28 2a 5b 27 7b  (sorted,zip(*['{
00000020: 3a 30 37 62 7d 27 2e 66 6f 72 6d 61 74 28 6f 72  :07b}'.format(or
00000030: 64 28 57 29 29 66 6f 72 09 57 09 69 6e 09 53 5d  d(W))for.W.in.S]
00000040: 29 29 0a 09 72 65 74 75 72 6e 09 4f 5b 31 3a 5d  ))..return.O[1:]
00000050: 3d 3d 4f 5b 3a 2d 31 5d 23 56 5f 5f 5f 5f 5f 5f  ==O[:-1]#V______
00000060: 5f 5f 5f 5f 5f 5f 5f 16 16 16 16 16 16 16 16 16  _______.........
00000070: 16 16 14 14 10                                   .....

Se leggi la descrizione della segnalazione di bug ... "risoluzione: non un bug".
mbomb007,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.