Вопросы Теги

Гольф кода - преобразовывает в шестнадцатеричную систему к (необработанному) двоичному преобразованию

Ваш пример не воспроизводим, потому что вы не предоставили данные.

Следующий пример воспроизводим и не дает ошибки. 

library(smooth)
forecast(sma(USAccDeaths))

Обратите внимание, что используемая здесь функция forecast не является частью пакета fpp2. Это из гладкой упаковки.

Чтобы проверить, что происходит с вашим примером:

  • Сначала проверьте, правильно ли считываются ваши данные.
  • Затем убедитесь, что функция sma возвращает что-то разумное. Сообщение об ошибке указывает на то, что функция не возвращает модель, которую она должна.
12
задан 5 revs, 3 users 42%unknown 23 May 2017 в 12:13
поделиться

15 ответов

edit Шашки сократили моё решение C до 46 bytes , который затем был уменьшен до 44 байтов благодаря подсказке от BillyONeal плюс исправление с моей стороны (больше нет бесконечного цикла при неправильном вводе, теперь он просто завершает цикл). Пожалуйста, отдайте должное Checkers за уменьшение этого значения с 77 до 46 байт: 

main(i){while(scanf("%2x",&i)>0)putchar(i);}

И у меня есть намного лучшее решение Ruby, чем мое последнее, в 42 38 байт (спасибо Джошуа Суонку за регулярное выражение предложение): 

STDIN.read.scan(/\S\S/){|x|putc x.hex}

исходные решения

C, в 77 байтах или двух строках кода (было бы 1, если бы вы могли поместить #include в одну строку). Обратите внимание, что это имеет бесконечный цикл при неправильном вводе; 44-байтовое решение с помощью Checkers и BillyONeal исправляет ошибку,

8
ответ дан 2 December 2019 в 03:22
поделиться

Я знаю, что Джон уже опубликовал (более чистое) решение LINQ. Но на этот раз я могу использовать оператор LINQ, который изменяет строку во время ее выполнения и злоупотребляет отложенной оценкой LINQ, не выкрикивая мои коллеги. : p 

string hex = "FFA042";
byte[] bytes =
    hex.ToCharArray()
       .Select(c => ('0' <= c && c <= '9') ? 
                         c - '0' :
                         10 + (('a' <= c) ? c - 'a' : c - 'A'))
       .Select(c => (hex = hex.Remove(0, 1)).Length > 0 ? (new int[] {
           c,
           hex.ToCharArray()
                 .Select(c2 => ('0' <= c2 && c2 <= '9') ?
                                    c2 - '0' :
                                    10 + (('a' <= c2) ? c2 - 'a' : c2 - 'A'))
                 .FirstOrDefault() }) : ( new int[] { c } ) )
       .Where(c => (hex.Length % 2) == 1)
       .Select(ca => ((byte)((ca[0] << 4) + ca[1]))).ToArray();

1 оператор, отформатированный для удобства чтения.

Обновление

Поддержка пробелов и неравномерного количества десятичных знаков (89A равно 08 9A) 

byte[] bytes =
    hex.ToCharArray()
       .Where(c => c != ' ')
       .Reverse()
       .Select(c => (char)(c2 | 32) % 39 - 9)
       .Select(c => 
           (hex =
                new string('0', 
                           (2 + (hex.Replace(" ", "").Length % 2)) *
                                hex.Replace(" ", "")[0].CompareTo('0')
                                                       .CompareTo(0)) +
                hex.Replace(" ", "").Remove(hex.Replace(" ", "").Length - 1))
              .Length > 0 ? (new int[] {
                        hex.ToCharArray()
                           .Reverse()
                           .Select(c2 => (char)(c2 | 32) % 39 - 9)
                           .FirstOrDefault(), c }) : new int[] { 0, c } )
                     .Where(c => (hex.Length % 2) == 1)
                     .Select(ca => ((byte)((ca[0] << 4) + ca[1])))
                     .Reverse().ToArray();

Еще один оператор. Можно было бы сделать намного короче, запустив replace ("", "") в шестнадцатеричной строке в начале, но это было бы вторым утверждением.

Два интересных момента с этим. Как отслеживать количество символов без помощи внешних переменных, кроме самой исходной строки. При решении этой проблемы я столкнулся с тем фактом, что char y.CompareTo (x) просто возвращает «y - x», а int y.CompareTo (x) возвращает -1, 0 или 1.

0
ответ дан 2 December 2019 в 03:22
поделиться

Я не могу закодировать это на макушке, но для каждых двух символов выведите (в байтах) ((AsciiValueChar1- (AsciiValueChar1> 64? 48: 55) * 16) + (AsciiValueChar1- (AsciiValueChar1> 64? 48: 55))), чтобы получить шестнадцатеричную строку, замененную на необработанный двоичный файл. Это ужасно сломалось бы, если бы в вашей входной строке было что-то отличное от 0 до 9 или от A до B, поэтому я не могу сказать, насколько это было бы полезно для вас.

0
ответ дан 2 December 2019 в 03:22
поделиться

Довольно удобочитаемое решение C (9 "реальных" строк): 

#include <stdio.h>
int getNextHexDigit() {
    int v;
    while((v = fgetc(stdin)) < '0' && v != -1) {    /* Until non-whitespace or EOF */
    }
    return v > '9' ? 9 + (v & 0x0F) : v - '0';      /* Extract number from hex digit (ASCII) */
}
int main() {
    int v;
    fputc(v = (getNextHexDigit() << 4) | getNextHexDigit(), stdout);
    return v > 0 ? main(0) : 0;
}

Для поддержки 16-разрядного байтового порядка байтов заменить main на: 

int main() {
    int v, q;
    v = (getNextHexDigit() << 4) | getNextHexDigit();
    fputc(q = (getNextHexDigit() << 4) | getNextHexDigit(), stdout);
    fputc(v, stdout);
    return (v | q) > 0 ? main(0) : 0;
}
1
ответ дан 2 December 2019 в 03:22
поделиться

Гах.

Тебе не разрешено звонить мне по моим сумасшедшим оценкам! ;-P

Вот 9-строчная версия C без нечетного форматирования (хорошо, я предоставлю вам, что массив tohex лучше разбить на 16 строк, чтобы вы могли видеть, какие коды символов соответствуют каким значениям ...) и только 2 ярлыка, которые я бы не развернул ни в чем, кроме одноразового скрипта: 

#include <stdio.h>
char hextonum[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
char input[81]="8b1f0008023149f60300f1f375f40c72f77508507676720c560d75f002e5ce000861130200000000";
void main(void){
   int i = 0;
   FILE *fd = fopen("outfile.bin", "wb");
   while((input[i] != 0) && (input[i+1] != 0))
      fputc(hextonum[input[i++]] * 16 + hextonum[input[i++]], fd);
}

Нет комбинированных строк (каждому выражению присваивается собственная строка), он отлично читается и т. д. Обфусцированная версия, несомненно, может быть короче можно обмануть и поставить закрывающие скобки в той же строке, что и предыдущее утверждение, и т. д., и т. д. и т. д.

Мне не нравится в этом две вещи: у меня нет закрывающего (fd) в там, и main не должен быть пустым и должен возвращать int. Возможно, они В этом нет необходимости - операционная система освобождает каждый ресурс, используемый программой, файл закрывается без проблем, а компилятор позаботится о значении выхода программы. Учитывая, что это сценарий одноразового использования, это приемлемо, но не развертывайте его.

Он становится одиннадцатью линиями с обоими, так что в любом случае это не очень большое увеличение, и версия из десяти строк будет включать одну или другую в зависимости на котором кто-то может почувствовать себя арендодателем двух зол.

Он не проверяет ошибки и не пропускает пробелы - при условии, опять же, что это разовая программа, тогда она быстрее выполняет поиск / замену и избавиться от пробелов и других пробелов перед запуском скрипта, однако для того, чтобы есть пробелы, не нужно больше, чем несколько строк.

Конечно, есть способы сделать его короче, но они, вероятно, значительно снизят читабельность ...

Хмф. Просто прочитайте комментарий о длине строки , так что вот более новая версия с более уродливым макросом гекстона, а не с массивом: 

#include <stdio.h>
#define hextonum(x) (((x)<'A')?((x)-'0'):(((x)<'a')?((x)+10-'A'):((x)+10-'a')))
char input[81]="8b1f0008023149f60300f1f375f40c72f77508507676720c560d75f002e5ce000861130200000000";
void main(void){
   int i = 0;
   FILE *fd = fopen("outfile.bin", "wb");
   for(i=0;(input[i] != 0) && (input[i+1] != 0);i+=2)
      fputc(hextonum(input[i]) * 16 + hextonum(input[i+1]), fd);
}

Это ужасно нечитабельно, но я знаю, что у многих людей есть проблемы с троичным оператор, но соответствующее именование макроса и некоторый анализ должны легко дать представление о том, как он работает для среднего программиста на Си. Из-за побочных эффектов в макросе мне пришлось перейти к циклу for, поэтому у меня не было другой строки для i + = 2 ( hextonum (i ++) будет увеличивать i на 5 каждый раз, когда он вызывается, макро-побочные эффекты не для слабонервных!).

Кроме того, анализатор ввода должен пропускать / игнорировать пробелы.

ворчать, ворчать, ворчать.

Мне пришлось добавить несколько строк, чтобы позаботиться об этом требовании, теперь до 14 строк для разумно отформатированной версии. Он будет игнорировать все, что не является шестнадцатеричным символом: 

#include <stdio.h>
int hextonum[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
char input[]="8b1f 0008 0231 49f6 0300 f1f3 75f4 0c72 f775 0850 7676 720c 560d 75f0 02e5 ce00 0861 1302 0000 0000";
void main(void){
   unsigned char i = 0, nibble = 1, byte = 0;
   FILE *fd = fopen("outfile.bin", "wb");
   for(i=0;input[i] != 0;i++){
      if(hextonum[input[i]] == -1)
         continue;
      byte = (byte << 4) + hextonum[input[i]];
      if((nibble ^= 0x01) == 0x01)
         fputc(byte, fd);
   }
}

Я не беспокоился о длине строки из 80 символов, потому что ввод не меньше 80 символов, но трехуровневый макрос из трех уровней мог бы заменить первый массив из 256 записей. Если не возражать против «альтернативного форматирования», то следующая 10-строчная версия не является полностью нечитаемой: 

#include <stdio.h>
int hextonum[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
char input[]="8b1f 0008 0231 49f6 0300 f1f3 75f4 0c72 f775 0850 7676 720c 560d 75f0 02e5 ce00 0861 1302 0000 0000";
void main(void){
   unsigned char i = 0, nibble = 1, byte = 0;
   FILE *fd = fopen("outfile.bin", "wb");
   for(i=0;input[i] != 0;i++){
      if(hextonum[input[i]] == -1) continue;
      byte = (byte << 4) + hextonum[input[i]];
      if((nibble ^= 0x01) == 0x01) fputc(byte, fd);}}

И, опять же, дальнейшая запутывание и переворачивание битов может привести к еще более короткому примеру.

но троичный трехуровневый макрос мог бы заменить первый массив из 256 записей. Если не возражать против «альтернативного форматирования», то следующая 10-строчная версия не является полностью нечитаемой: 

#include <stdio.h>
int hextonum[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
char input[]="8b1f 0008 0231 49f6 0300 f1f3 75f4 0c72 f775 0850 7676 720c 560d 75f0 02e5 ce00 0861 1302 0000 0000";
void main(void){
   unsigned char i = 0, nibble = 1, byte = 0;
   FILE *fd = fopen("outfile.bin", "wb");
   for(i=0;input[i] != 0;i++){
      if(hextonum[input[i]] == -1) continue;
      byte = (byte << 4) + hextonum[input[i]];
      if((nibble ^= 0x01) == 0x01) fputc(byte, fd);}}

И, опять же, дальнейшая запутывание и переворачивание битов может привести к еще более короткому примеру.

но троичный трехуровневый макрос мог бы заменить первый массив из 256 записей. Если не возражать против «альтернативного форматирования», то следующая 10-строчная версия не является полностью нечитаемой: 

#include <stdio.h>
int hextonum[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
char input[]="8b1f 0008 0231 49f6 0300 f1f3 75f4 0c72 f775 0850 7676 720c 560d 75f0 02e5 ce00 0861 1302 0000 0000";
void main(void){
   unsigned char i = 0, nibble = 1, byte = 0;
   FILE *fd = fopen("outfile.bin", "wb");
   for(i=0;input[i] != 0;i++){
      if(hextonum[input[i]] == -1) continue;
      byte = (byte << 4) + hextonum[input[i]];
      if((nibble ^= 0x01) == 0x01) fputc(byte, fd);}}

И, опять же, дальнейшая запутывание и переворачивание битов может привести к еще более короткому примеру.

2
ответ дан 2 December 2019 в 03:22
поделиться

Perl

Конечно, в одной (довольно короткой) строке: 

my $bin = map { chr hex } ($hex =~ /\G([0-9a-fA-F]{2})/g);
2
ответ дан 2 December 2019 в 03:22
поделиться

РЕДАКТИРОВАТЬ: Этот код был написан задолго до редактирования вопроса, который конкретизировал требования.

Учитывая, что одна строка C может содержать огромное количество операторов, это почти наверняка верно, но бесполезно.

В C # я почти наверняка напишу это более чем в 10 строках, даже если это будет выполнимо . ] в 10. Я бы отделил часть «parse nybble» от части «преобразовать строку в массив байтов».

Конечно, если вам не нужно определять неправильные длины и т. д., это становится немного Полегче. Ваш оригинальный текст также содержал пробелы - если они будут пропущены, проверены, и т.д? Являются ли они частью требуемого формата ввода ?

Я скорее подозреваю, что комментарий был сделан без учета того, как будет выглядеть приятное, читаемое решение.

Сказав это, вот отвратительный версия на C #. Для получения бонусных баллов он использует LINQ совершенно неуместно, чтобы сохранить одну или две строки кода. Конечно, строки могут быть длиннее ... 

using System;
using System.Linq;

public class Test
{
    static void Main(string[] args)
    {
        byte[] data = ParseHex(args[0]);
        Console.WriteLine(BitConverter.ToString(data));

    }

    static byte[] ParseHex(string text)
    {
        Func<char, int> parseNybble = c => (c >= '0' && c <= '9') ? c-'0' : char.ToLower(c)-'a'+10;
        return Enumerable.Range(0, text.Length/2)
            .Select(x => (byte) ((parseNybble(text[x*2]) << 4) | parseNybble(text[x*2+1])))
            .ToArray();
    }
}

(Это позволяет избежать "мошенничества" с помощью любого встроенного шестнадцатеричного кода синтаксического анализа, такого как Convert.ToByte (string, 16) . Помимо что-нибудь еще, это означало бы потерю использования слова nybble, которое всегда является бонусом.)

он использует LINQ совершенно неуместно, чтобы сохранить одну или две строки кода. Конечно, строки могут быть длиннее ... 

using System;
using System.Linq;

public class Test
{
    static void Main(string[] args)
    {
        byte[] data = ParseHex(args[0]);
        Console.WriteLine(BitConverter.ToString(data));

    }

    static byte[] ParseHex(string text)
    {
        Func<char, int> parseNybble = c => (c >= '0' && c <= '9') ? c-'0' : char.ToLower(c)-'a'+10;
        return Enumerable.Range(0, text.Length/2)
            .Select(x => (byte) ((parseNybble(text[x*2]) << 4) | parseNybble(text[x*2+1])))
            .ToArray();
    }
}

(Это позволяет избежать "мошенничества" с помощью любого встроенного шестнадцатеричного кода синтаксического анализа, такого как Convert.ToByte (string, 16) . Помимо что-нибудь еще, это означало бы потерю использования слова nybble, которое всегда является бонусом.)

он использует LINQ совершенно неуместно, чтобы сохранить одну или две строки кода. Конечно, строки могут быть длиннее ... 

using System;
using System.Linq;

public class Test
{
    static void Main(string[] args)
    {
        byte[] data = ParseHex(args[0]);
        Console.WriteLine(BitConverter.ToString(data));

    }

    static byte[] ParseHex(string text)
    {
        Func<char, int> parseNybble = c => (c >= '0' && c <= '9') ? c-'0' : char.ToLower(c)-'a'+10;
        return Enumerable.Range(0, text.Length/2)
            .Select(x => (byte) ((parseNybble(text[x*2]) << 4) | parseNybble(text[x*2+1])))
            .ToArray();
    }
}

(Это позволяет избежать "мошенничества" с помощью любого встроенного шестнадцатеричного кода синтаксического анализа, такого как Convert.ToByte (string, 16) . Помимо что-нибудь еще, это означало бы потерю использования слова nybble, которое всегда является бонусом.)

3
ответ дан 2 December 2019 в 03:22
поделиться

В Python: 

binary = binascii.unhexlify(hex_str)

ОДНА ЛИНИЯ! (Да, это обман.)

4
ответ дан 2 December 2019 в 03:22
поделиться

77-байтовое C-решение Брайана может быть улучшено до 44 байтов благодаря сниженному значению C с относительно прототипов функций. 

main(i){while(scanf("%2x",&i)>0)putchar(i);}
6
ответ дан 2 December 2019 в 03:22
поделиться

45-байтовый исполняемый файл (в кодировке base64): 

6BQAitjoDwDA4AQI2LQCitDNIevrWMOy/7QGzSF09jLkBMAa5YDkByrEJA/D

(вставить в файл с расширением .com)

РЕДАКТИРОВАТЬ: Хорошо, вот код. Откройте консоль Windows, создайте файл с 45 байтами с именем «hex.com», введите «debug hex.com», затем «a» и введите. Скопируйте и вставьте эти строки: 

db e8,14,00,8a,d8,e8,0f,00,c0,e0,04,08,d8,b4,02,8a,d0,cd,21,eb,eb,cd,20
db b2,ff,b4,06,cd,21,74,f6,32,e4,04,c0,1a,e5,80,e4,07,2a,c4,24,0f,c3

Нажмите клавишу ввода, «w», а затем введите снова, «q» и введите. Теперь вы можете запустить «hex.com».

EDIT2: Сделано на два байта меньше! 

db e8, 11, 00, 8a, d8, e8, 0c, 00, b4, 02, 02, c0, 67, 8d, 14, c3
db cd, 21, eb, ec, ba, ff, 00, b4, 06, cd, 21, 74, 0c, 04, c0, 18
db ee, 80, e6, 07, 28, f0, 24, 0f, c3, cd, 20

Это было сложно. Я не могу поверить, что потратил время на это.

7
ответ дан 2 December 2019 в 03:22
поделиться

Haskell: 

import Data.Char
import Numeric
import System.IO
import Foreign

main = hGetContents stdin >>= 
       return.fromHexStr.filter (not.isSpace) >>=  
       mapM_ (writeOneByte stdout)

fromHexStr (a:b:tl) = fromHexDgt [a,b]:fromHexStr tl
fromHexStr [] = []
fromHexDgt str =  case readHex str of 
  [(i,"")] -> fromIntegral (i)
  s -> error$show s

writeOneByte h i = allocaBytes 1 (wob' h i)
wob' :: Handle -> Int8 -> (Ptr Int8) -> IO ()
wob' h i ptr = poke ptr i >> hPutBuf h ptr 1
2
ответ дан 2 December 2019 в 03:22
поделиться

39 символов на вкладке 

y/A-Fa-f0-9//dc,print pack"H*",$_ for<>

Редактировать: не принимал прописные буквы, исправлено.

7
ответ дан 2 December 2019 в 03:22
поделиться

31-символьное решение Perl:

s / \ W // g, print (pack'H * ', $ _) for <>

1
ответ дан 2 December 2019 в 03:22
поделиться

PHP , 28 символов: 

<?=pack(I,hexdec($argv[1]));
0
ответ дан 2 December 2019 в 03:22
поделиться 
.

Это язык под названием «Hex!». Его единственное использование - читать шестнадцатеричные данные из stdin и выводить их на stdout. Hex! анализируется простым скриптом Python. import sys 

try:
  data = open(sys.argv[1], 'r').read()
except IndexError:
  data = raw_input("hex!> ")
except Exception as e:
  print "Error occurred:",e

if data == ".":
  hex = raw_input()
  print int(hex, 16)
else:
  print "parsing error"
2
ответ дан 2 December 2019 в 03:22
поделиться
Другие вопросы по тегам:

Похожие вопросы: