Hello World 0.0!


78

Дилберт потрясающий
Источник: Дилберт, 8 сентября 1992 г.

Я надеюсь добавить новый поворот в классическом "Hello World!" программа.

Код программы, которая выводит Hello World!без:

  • Строковые / символьные литералы
  • Числа (любая база)
  • Предварительно встроенные функции, которые возвращают "Hello World!"
  • Регулярные литералы

За исключением «O» и 0.

† «O» пишется с заглавной буквы, «o» не допускается.


4
Один из [code-golf] и [code-challenge], пожалуйста, не оба. Смысл этих тегов в том, чтобы помочь людям найти вопросы с правилами, которые они хотят использовать. По сути, каждый вопрос на этом сайте должен быть той или иной игрой.
dmckee

4
-1 У нас уже был Обфусцированный Hello World , и я думаю, что этот вызов слишком похож. Я бы проголосовал «близко как дубликат», если бы я не был модом.
Крис Шут-Янг

2
@zzzzBov: я не думаю, что это достаточно отличается, чтобы оправдать другой вопрос в теме «Привет, мир»; другая тема была бы лучше. Но это только мое мнение.
Крис Шестер-Янг

1
Я думаю, что это хороший код гольф - и лучше, чем предыдущий.
MtnViewMark

2
Некоторые люди, кажется, предполагают, что это "O"*означает, что они могут иметь строковый литерал с любым числом О, включая ноль. Я не думаю, что это было намерение. Просьба уточнить.
Тимви

Ответы:


83

Windows PowerShell, слишком много

Да, действительно, в то время мы должны были написать «Hello world», используя (почти исключительно) нули ...

&{-join[char[]]($args|% Length)} `
O00000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000

На более серьезной ноте:

Windows PowerShell, 25

Write-Host Hello World!

Нет строкового литерала. Hello World!Там как раз случается быть проанализирован как строка , поскольку PowerShell находится в режиме разбора аргументов там.


2
Как это реально? О_о
Джош

1
Я искал в Интернете некоторые примеры или историю этого. Это так странно. Не могли бы вы предоставить какие-либо ссылки?
Калеб Ярес

1
"В былые времена". :) Ты миллениалы

Ой. Одинарный. Я понял
Мэтью Ро

86

C 327 символов

#define O(O)-~O
#define OO(o)O(O(o))
#define Oo(o)OO(OO(o))
#define oO(o)Oo(Oo(o))
#define oo(o)oO(oO(o))
#define O0 putchar
main() {
    O0(OO(oO(!O0(~O(Oo(OO(-O0(~O(Oo(-O0(O(OO(O0(oo(oO(O0(O(oo(oO(OO(Oo(oo(oO(
    O0(oo(oo(!O0(O(OO(O0(O0(O(OO(Oo(O0(O(Oo(oo(oO(O0(oo(oo(oO(oo(oo(0))))))))
    ))))))))))))))))))))))))))))))))))))));
}

Как ни странно, он не теряет своей красоты после предварительной обработки:

main() {
putchar(-~-~-~-~-~-~-~-~-~-~!putchar(~-~-~-~-~-~-~-~-putchar(~-~-~-~-~-~-
putchar(-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~!putchar(-~-~-~putchar(putchar(-~-~-~-~-~-~-~putchar
(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0))))))))))));
}

2
Потрясающие. Отсутствует!
Марк Рид

1
Это настоящее искусство!
Аскага

Я чувствую, что тело может быть сокращено с еще большим количеством препроцессоров. Не уверен, что код в целом выиграет, хотя.
Zwei

@ Zwei, это конечно можно сократить. Я не старался найти оптимальный набор макросов.
Угорен

Почему бы вам не включить парены в CLANG #define? сэкономит несколько байтов, нет? Редактировать: неважно, только что попробовал, и теперь я понимаю, почему это не сработает ахаха
Альберт Реншоу

52

BrainFuck, 102 111 персонажей

++++++++[>++++[>++>+++>+++>+<<<<-]>+>->+>>+[<]<-]>>.>>---.+++++++..+++.>.<<-.>.+++.------.--------.>+.

Соответствует всем правилам.

Кредит идет к Даниэлю Кристофани .


1
Я не могу решить, должны ли правила также заявить 0 and/or "O" must be used. Это немного неважно для BrainFuck и golfscript, но им точно не трудно справиться с этой задачей.
zzzzBov

35
@zzzzBov: если они должны быть использованы, то код Brainfuck будет просто включать их. Они не влияют на программу, хотя.
Джои

38

C 182 байта

#define decode(c,o,d,e,g,O,l,f) e##c##d##o
#define HelloWorld decode(a,n,i,m,a,t,e,d)
#define Puzzles(flog) #flog
#define CodeGolf Puzzles(Hello World!)
HelloWorld(){puts(CodeGolf);}

1
+1, лол, вы все еще используете трюк с оператором вставки токена! Хороший приятель :-)
Quixotic

35

C программа - 45

(мошенничество)

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

#define s(x)#x
main(){puts(s(Hello World!));}

3
Для очень удобного понятия "лексически" :) Но дерзость FTW!
JB

24

Хаскель - 143 персонажа

o%y=o.o.o$y;o&y=(o%)%y;o!y=o$o$(o%)&y
r=succ;w=pred;a=r%y;e=r$w&l;l=r!'O';o=r e;u=(w&)&a;y=r%l
main=putStrLn[w!o,o,l,l,y,w u,w$r&'O',y,a,l,e,u]

ой, это было неопрятно!

Нет чисел, нет числовых операций, переменные переименованы для развлечения.

Некоторая экспозиция может быть хорошей:

  • o%y, o&yИ o!yкаждый применяет функцию oк yмногократно: 3, 9, и 29 раз соответственно. 29?!?! Да, 29!
  • rи wявляются следующим и предыдущим символом, который при применении с использованием вышеупомянутых функций высшего порядка может быть сделан для получения всех необходимых символов 'O'.

Необходимая последовательность прыжков:

'O' +29    -> 'l'
'O'  +9 -1 -> 'W'
'l'  -9 +1 -> 'd'
'l'  +3    -> 'o'
'd'  +1    -> 'e'
'o'  +3    -> 'r'
'e' -29    -> 'H'
'r' -81    -> '!'
'!'  -1    -> ' '

  • Изменить: (134 -> 144) Забыл вывести восклицательный знак, вздох ....
  • Edit: (144 -> 143) Удален ненужный $, переименованный #в !течение Hugs.

1
хорошо? oo ....
Джои Адамс

Не работает codepad.org/lyKyj1Ox
nyuszika7h

@ Nyuszika7H Это потому, что этот сервис по умолчанию включает некоторые опции компилятора. Он должен компилироваться с простым GHC.
FUZxxl

@ Nyuszika7H С GHC все работает отлично. Проблема в том, что эта служба использует Hugs с 2006 года. Похоже, что Hugs не может справиться с двумя вещами: 1) Использование «#» в качестве оператора. Меняется на '!' заставляет это работать. 2) Определения r=succи w=predнесоответствие того, как Хагс реализует ограничение мономорфизма. Меняется r x=succ xи w x=pred xзаставляет его работать (по стоимости 4 символа). Кажется, это проблемы в объятиях.
MtnViewMark

Это все еще действует после редактирования @Community?
Hosch250

22

Unary , 10 197 1137672766964589547169964037018563746793726105983919528073581559828 байт

Я удивлен, что никто еще не сделал это ...

Это слишком долго, чтобы публиковать здесь, но это 1137672766964589547169964037018563746793726105983919528073581559828 нулей.

Или, более легко читать: ~ 10 67 нулей.

Спасибо @dzaima за сохранение 10 197 байт


2
Когда я прочитал «Я однажды написал всю базу данных, используя только нули», моей первой мыслью было «он, должно быть, сделал это в унарном виде». +1 за то, что был единственным ответом, чтобы работать именно так, как сделал комикс
Cyoce

21

Mathematica 12 символов

Только символы, без строк.

Hello World!   

! является факториальным оператором, но, поскольку символы Hello и World не определены, возвращает входные данные без изменений.

Если мы немного изменим программу:

Hello=2;
World=3;
Hello World!  

Затем он печатает 12(2 * 3!)


16

сборка i386 (Linux, синтаксис gcc), 440 442 435

Сегодня мой день собрания, и после этого мне будет достаточно на некоторое время. Я позволил себе номер 128, см. Ниже программу для обсуждения почему. Ничего необычного: я просто кодирую "Hello World!" в качестве кодов сборки, где это имеет смысл без числовых констант, а остальные заполняются арифметикой.

#define M mov
M $0,%ecx;inc %cx;M %ecx,%ebx;inc %cx;M %ecx,%eax;add %ax,%ax
M %ecx,%edx;shl %cl,%dx;M (e),%ch;add %dl,%ch;dec %ch;M %ch,(l)
M %ch,(j);M %ch,(z);M $0,%ch;shl %cl,%edx;M %dl,(s);inc %dl
M %dl,(b);M (o),%dl;M %dl,(u);add %al,%dl;dec %dl;M %dl,(r)
M $m,%ecx;M $n,%edx;int $c;M %ebx,%eax;M $0,%ebx;int $c
.data
m:dec %eax;e:gs;l:es;j:es;o:outsl (%esi),(%dx)
s:es;push %edi;u:es;r:es;z:es;fs;b:es;n=.-m
t=(n+n)/n;c=t<<(t*t+t)

(собрать с gcc -nostartfiles hello.S -o hello, возможно, в -m32зависимости от вашей арки)

Почему допуск на 128? Мне нужны системные вызовы, чтобы показать что-нибудь; Системные вызовы Linux находятся на INT 80h (128 десятичных); единственный формат операнда для INT является немедленным, поэтому невозможно иметь что-либо кроме константы (к коду). Я мог (после того, как стал трезвым) пытаться выразить это как функцию других символических констант в коде, вероятно, n , но это становится очень скучным из-за небольшого выигрыша. Я прочитал ограничение на числа как способ предотвращения кодирования ASCII, и это определенно не то, что я делаю здесь, поэтому я чувствую себя достаточно невинным, чтобы представить это. (FWIW, я также попробовал самоизменяющийся код, но он был поврежден) Теперь также не осталось и 128. Код чистый!

  • Edit1 переформатирован для сохранения строк; убрал цифру 1 (никто не заметил ?!)
  • Edit2 сжатый movмакросами CPP; устранены оставшиеся 128.

6
Так программируют настоящие мужчины.
Нить

14

Javascript - 305

Немного долго, но мне нравится используемый метод.

O=0;O++;O=O.toString();alert([O+0+0+O+0+0+0,0+O+O+0+0+O+0+O,O+O+0+O+O+0+0,O+O+0+O+O+0+0,O+O+0+O+O+O+O,O+0+0+0+0+0,O+0+O+0+O+O+O,O+O+0+O+O+O+O, O+O+O+0+0+O+0,O+O+0+O+O+0+0,O+O+0+0+O+0+0,O+0+0+0+0+O].map(function(e){O=0;O++;O++;return String.fromCharCode(parseInt(e,O))}).reduce(function (a,b){return a+b}))

Мне это нравится. Было бы лучше с параметрами функции , как OO, OOO, но, конечно же, что бы сделать его больше.
zzzzBov

Действительно мило. Должен ли ', new String ()' быть в конце? Кажется, работает без него.
Стивен Перельсон,

3
Ах, нет, это не так. Иногда я забываю, насколько слабо типизирован Javascript.
david4dev

Вам также не нужны левые 0 бит ('0+'), а пробел и восклицательный знак имеют два левых 0 бита. Общее сокращение 28 символов.
Стивен Перельсон,

10

C # (131 символ)

141 символ 142 символа

enum X{Hello,World,A,B=A<<A<<A}class Y{static void Main(){var c=(char)X.B;System.Console.Write(X.Hello.ToString()+c+++X.World+c);}}

Удобочитаемый:

// Define some constants (B = 32)
enum X { Hello, World, A, B = A << A << A }
class Y
{
    static void Main()
    {
        // Generate the space (character #32)
        var c = (char) X.B;

        // Remember that “!” is character #33
        System.Console.Write(X.Hello.ToString() + c++ + X.World + c);
    }
}

2
это круто и приятно. Я люблю это.
Jcolebrand

+1 хороший способ генерировать определенные числа. Должен помнить это!
Игби Большой человек

Программа LINQPad, 102 знака:enum X{Hello,World,A,B=A<<A<<A}void Main(){var c=(char)X.B;(X.Hello.ToString()+c+++X.World+c).Dump();}
Cœur,

.ToString()-> +""Сохраняет некоторые кадры
Firo

2
@Firo: ... и нарушает правила. (Строковые литералы не допускаются.)
Тимви

8

JavaScript, 88

t=!0<<-~-~-~-~!0
r=[]
for(i in{Hello:"O",World:0})r+=i+String.fromCharCode(t++)
alert(r)

99

Большое спасибо @Timwi за предложения

удален троичный оператор:

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
r=c(0)
for(i in o)r+=i+c(t++)
alert(r)

103
псевдонимString.fromCharCode

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
for(i in o)o[i]?r=i+c(t):alert(r+i+c(++t))

117
Переключен if-else на троичный оператор

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)o[i]?r=i+String.fromCharCode(t):alert(r+i+String.fromCharCode(++t))

125
Я придерживаюсь "O"только того, чтобы иметь «О» в программе.

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else alert(r+i+String.fromCharCode(++t))

133

o={Hello:"O",World:0},t=!0<<(!0+!0<<!0)+!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else r+=i+String.fromCharCode(t+!0)
alert(r)

@ Джои, это во многом суть.
zzzzBov

@ Джои, я прочитал в метаданных Codegolf, что в течение некоторого времени следует избегать ответов на их собственные вопросы, чтобы побудить других попробовать различные подходы. Мой план состоял в том, чтобы раскомментировать это через день или два.
zzzzBov

@ Джои, в то время я не работал на своей машине, и мне не хотелось писать ответ по электронной почте, когда я мог просто опубликовать его в комментарии.
zzzzBov

@Joey: «Их всего пять» - это неправильно. Любой может предложить редактирование. Просто нажмите «изменить» между «ссылка» и «флаг», и вы можете увидеть код.
Джон

@zzz: «в этом вся суть». Любой может увидеть это. Любой может предложить редактирование, нажав «изменить» между «ссылкой» и «флагом», что откроет диалоговое окно редактирования, раскрывающее ваш код.
Джон

7

GolfScript, 63 символа

[0))):O.)?O.*-.O.?+)).O.*+((..O+.O(.O+?.O-O*@.O+O.+$.O.*-).O/]+

Что, еще нет записи GolfScript?

Этот использует один числовой литерал 0и переменную с именем O(которая используется для хранения числа 3). Все остальное - арифметика и манипуляции со стеком. Строка Hello World!построена из своих кодов ASCII, символ за символом.

Вот как это работает:

[             # insert start-of-array marker
  0))):O      # increment 0 thrice to get 3, and save it in the variable O
  .)?O.*-     # calculate 3^(3+1) - 3*3 = 81 - 9 = 72 = "H" 
  .O.?+))     # calculate 72 + 3^3 + 1 + 1 = 72 + 27 + 2 = 101 = "e"
  .O.*+((     # calculate 101 + 3*3 - 1 - 1 = 101 + 9 - 2 = 108 = "l"
  .           # ...and duplicate it for another "l"
  .O+         # calculate 108 + 3 = 111 = "o"
  .           # ...and duplicate it for later use
  O(.O+?      # calculate (3-1)^(3-1+3) = 2^5 = 32 = " "
  .O-O*       # calculate (32 - 3) * 3 = 29 * 3 = 87 = "W"
  @           # pull the second 111 = "o" to the top of the stack
  .O+         # calculate 111 + 3 = 114 = "r"
  O.+$        # copy the (3+3 = 6)th last element on the stack, 108 = "l", to top
  .O.*-)      # calculate 108 - (3*3) + 1 = 108 - 9 + 1 = 100 = "d"
  .O/         # calculate int(100 / 3) = 33 = "!"
]             # collect everything after the [ into an array
+             # stringify the array by appending it to the input string

7

Brainfuck, 111 байт

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++
.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.
------.--------.>+.>.

Алгоритм объяснил

Increment cell 0 to 10 (it will be loop counter)
Repeat 10 times ; will stop at cell 0
  Increment cell 1 to 7
  Increment cell 2 to 10
  Increment cell 3 to 3
  Increment cell 4 to 1
Increment cell 1 by 2 and output it ; Thus, output ASCII 72 'H'
etc. for all symbols in 'Hello World!'

Более длинная версия без цикла, 389 байт:

+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+++++++++++++++++
++++++++++++.+++++++..+++.-------------------
---------------------------------------------
---------------.+++++++++++++++++++++++++++++
++++++++++++++++++++++++++.++++++++++++++++++
++++++.+++.------.--------.------------------
---------------------------------------------
----.-----------------------.

Это загадка для игры в гольф, смысл в том, чтобы создать максимально короткую программу. Часть этого включает в себя размещение длины вашего кода.
zzzzBov

5

Lua 144 97 86 символов

Другой подход, основанный на том факте, что ключи таблиц также являются строками, и на том факте, что #Hello == #World == 32 == string.byte '\ n'

e=#"O"t=e+e for k,v in pairs{Hello=0,World=e}do T=t^#k io.write(k,string.char(T+v))end

Решение 145 символов

  • нет строк, кроме "O" или 0
  • нет регулярных выражений
  • нет встроенных функций

Сделал дельта-кодирование байтов, затем некоторые простые числа и т. Д. И т. Д. :)

Гольф версия:

e=#"O"d=e+e t=d+e v=d+t z=v+t T=t^d*d^t n=0 for l,m in pairs{T,T/t-z,z,0,d,-T-z,z*z+t*d,T/d,d,-d*t,-t^d,-T+v}do n=n+m io.write(string.char(n))end

комментарии:

-- without numbers, strings, regex
-- except "O" and 0
e=#"0"
t=e+e --2
d=t+e -- 3
v=d+t -- 5
z=v+t -- 7
n=0
T=t^d*d^t -- 72 = 2^3+3^2
for l,m in pairs{T, --72
T/t-z, -- 29 = 72/2-7
z, --7
0, -- 0
d, -- 3
-T-z, -- -79 = -72 - 7
z*z+t*d, -- 55 = 7*7 + 2*3
T/d, -- 24 = 72/3
d, -- 3
-d*t, -- -6
-t^d, -- -8
-T+v -- -67 = -72+5
} do
    n=n+q[k]
    io.write(string.char(n))
end

Изменить: изменил несколько O-строк, и нашел еще несколько оптимизаций.


«О» * - я думаю, что * было для сноски, а не «любое число О»
RomanSt

Ну, регулярное выражение - это то, что я, естественно, делаю: с. Могли бы заменить его по цене 5 или 3 дополнительных символа соответственно для первого и второго решения
jpjacobs

Но в любом случае, я отредактирую их, спасибо за
заголовки

Hello и World в конструкторе таблиц по-прежнему являются строковыми литералами - это просто синтетический сахар.
Волков Олег Викторович

5

Питон ( 126 130)

O=ord("O")
N=O/O
T=N+N
R=N+T
E=T**R
E<<T
print'O'[0].join(chr(c+O)for c in[N-E,E*R-T,_-R,_-R,_,N-_-E-E,E,_,_+R,_-R,E*R-R,T-_-E-E])

Буквально ''не допускается.
RomanSt

1
@romkyns: Очень верно, исправлено.
Хоа Лонг Там

5
Не исправлено (неверный вывод). Вы, наверное, думаете [:0].
WolframH

5

J, 250

oo=:#a.
o0=:<.o.^0
o0o=:%:%:%:oo
ooo=:p:^:(-*oo)
o=:<.(^^^0)*(^^0)*(^^0)
o00=:o,~(,[)o0(**(**[))o0o
oo0=:*/p:(!0),>:p:!0
echo u:(o0(**(**]))o0o),(ooo ooo ooo(o.o.^^^0)*oo),o00,(+:%:oo),(oo0-~!p:>:>:0),o,(<.-:o.o.^o.^0),(>:p:(]^])#o00),(*:#0,#:oo),oo0

Мне было слишком весело с этим, и я научился немного больше J, чтобы загрузить. Кроме того, ooo ooo oooвозможно, это самый глупый код, который я когда-либо писал.


5

QR с полублоками (169) 121 символ

С QR-кодом с использованием символов UTF-8 Half-block:

▗▄▄▄▗▄▖▗▄▄▄  
▐▗▄▐▝█▙▐▗▄▐  
▐▐█▐▝▄ ▐▐█▐  
▐▄▄▟▗▗▗▐▄▄▟  
▗▗▖▄▞▝ ▗ ▖▄  
 ▟▜ Code ▀▟  
 ▙▀ Golf ▘▚  
▗▄▄▄▐▗▘▟▙▝▝  
▐▗▄▐▝▀▛▘▘█▖  
▐▐█▐▐▖▐▝▖▜▘  
▐▄▄▟▗ ▌█▛▗▝  3

К сожалению, это не будет хорошо выглядеть там. Есть небольшой фрагмент с соответствующей таблицей стилей, но .. Нет! Язык, представленный здесь, не является HTML! Язык, представленный здесь, является QR-кодом ! (HTML и CSS используются здесь только для устранения ошибки презентации!)

QR с полублоками (169)

  ▛▀▀▌▚▝▐▀▌▛▀▀▌
  ▌█▌▌▖▞▚▚▘▌█▌▌
  ▌▀▘▌ ▚▛▞ ▌▀▘▌
  ▀▀▀▘▚▌▙▘▌▀▀▀▘
  ▄▙▛▚▜▀▄▀█▖▝▄▌
  ▖▄▄▘▖▄▄▄▟▗ ▀▘
  ▜Code  golf!▌
  ▚▟▘▘▝▙▛▚▐▀▖▜▘
  ▘▘ ▀▛▗▚▗▛▀▌▄ 
  ▛▀▀▌▟▌▜▖▌▘█▐▘
  ▌█▌▌▘█▌▟█▜▙▐ 
  ▌▀▘▌▚▌▌█▗▝▌▚▘
  ▀▀▀▘ ▝▘▘▀▀▀▀▘

В идеале это может выглядеть так:

QR: Привет, мир!


Используйте свой смартфон, чтобы увидеть это или zbarпод Linux. (пример: xwd | xwdtopnm | zbarimg /dev/stdin)
F. Hauri

Разве Code golf!персонаж не является литералом?
Угорен

2
Я действительно думаю, что этот ответ, хотя и творческий, не подходит, потому что это не программа. QR - это способ кодирования данных, а не язык программирования.
Угорен

1
А как насчет языков, как postscript, svgили других языков представления, уже используемых там !? В любом случае, способ кодирования - это язык ... Я думаю!
Ф. Хаури

1
Я использовал HTML (без JS) в качестве примера того, что не является языком. То же самое касается QR. Смотрите эти критерии .
Угорен

4

Scala ( 357 423 361 символов)

К сожалению, не самый короткий ответ, но в надежде получить бонусные баллы за наибольшее использование 'O'и'0'

def h(){type t=scala.Char;def OO(c:t)={(c-('O'/'O')).toChar};def O(c:t)={OO(OO(OO(c)))};def O00(c:t)={(c+('O'/'O')).toChar};def O0(c:t)={O00(O00(O00(c)))};val l=O('O');val z=O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))));print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+l+l+'O'+OO(z)+O0(O0(O0(OO('O'))))+'O'+O0('O')+l+OO(OO(O(O(O('O')))))+z).toLowerCase)}

Ранее:

def h(){type t=scala.Char;print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+O('O')+O('O')+'O'+OO(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0))))))))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))))).toLowerCase);def OO[Char](c:t)={(c-('O'/'O')).toChar};def O[Char](c:t)={OO(OO(OO(c)))};def O00[Char](c:t)={(c+('O'/'O')).toChar};def O0[Char](c:t)={O00(O00(O00(c)))}}

Старая (нелегальная) версия:

def h(){type t=scala.Char;print(""+OO(O(O('O')))+(""+OO(O(O(O('O'))))+O('O')+O('O')+'O'+OO(O(O(O(O(O('0'))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O(O(O(O(O('0')))))).toLowerCase);def O0[Char](c:t)={O00(O00(O00(c)))};def O[Char](c:t)={OO(OO(OO(c)))};def OO[Char](c:t)={(c-('O'/'O')).toChar};def O00[Char](c:t)={(c+('O'/'O')).toChar}}

Я считаю, что пустая строка ( "") и строковые / символьные литералы, содержащие символ ноль ( '0'), не допускаются. Только строка "O"(заглавная O) и число 0.
Тимви

Мудак. Некоторое редактирование требуется тогда ...
Гарет

4

C (или C ++) (сегмент тела: 49) (обман)

при компиляции, скомпилировать в бинарный файл Hello\ World\!, код выглядит так:

#include <stdio.h>
#include <string.h>
int main(int i,char**a)
{
  int j=i+i,k=j<<j;puts(strrchr(*a,'O'-(k<<j))+i);
}

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

Типичная строка компиляции может быть: gcc -o Hello\ World\! foo.c


4

Java 389 символов

заметил ненужную декларацию

class A{static int a=0,b=a++,f=a,e=a++;static char p(String s){return(char)Byte.parseByte(s,a);}public static void main(String[]z){long x=e,y=b;String c=((Long)x).toString(),d=((Long)y).toString();char l=p(c+c+d+c+c+d+d),m=p(c+c+d+d+c+d+c),o=(char)(l+a+f),_=p(c+d+d+d+d+d),$=_++;System.out.print(new char[]{p(c+d+d+c+d+d+d),m,l,l,o,$,p(c+d+c+d+c+c+c),o,(char)(o+a+f),l,(char)(m-f),_});}}

История в истории редактирования, теперь читаемая оригинальная версия без гольфа:

// H  e  l    l   o      W  o  r   l    d  !
//72,101,108,108,111,32,87,111,114,108,100 33
import static java.lang.Integer.*;
class A
{


    public static void main(String[] args)
    {
        Integer a=0,b=a++,e=a++;  // making a 0 a 1 and a 2 which is required later;
        String c=e.toString(),d=b.toString(),z=c.substring(0,0);  //

        String H = ((char)parseInt(d+c+d+d+c+d+d+d,a))+z+  // make binary values and then to char
                (char)parseInt(d+c+c+d+d+c+d+c,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+d+c+d+d+d+d+d,a)+
                (char)parseInt(d+c+d+c+d+c+c+c,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+c+c+c+d+d+c+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+d+c+d+d,a)+
                (char)parseInt(d+d+c+d+d+d+d+c,a)
                ;
        System.out.println(H);  //obvious
    }

3

С ++, 141, 146

Первый раз, попробовав один из них, возможно, можно еще немного улучшить:

char o='O'/'O',T=o+o,X=T+o,f=T+X,t=f+f,F=t*f,h=F+F,l=h+t-T,O=l+X;
char c[]={F+t+t+T,h+o,l,l,O,o<<f,h-t-X,O,l+f+o,l,h,0};
cout<<c;

РЕДАКТИРОВАТЬ:

Украл уловку из другого поста, не могу поверить, что я об этом не подумал :(


1
Технически вы должны включить в число символов всю рабочую программу, включая такие, как main, любые включенные библиотеки std::и т. Д.
Wug

3

Хаскелл - 146

a:b:c:f:g:s:j:z=iterate(\x->x+x)$succ 0
y=[f+j,d+a,c+s+h,l,a+b+l,s,f-s+o,o,a+b+o,l,l-f,a+s]
[h,e,l,_,o,_,w,_,r,_,d,x]=y
main=putStrLn$map toEnum y

Я полагал, что сопоставление с образцом даст Хаскеллу огромную опору, в частности, потому что вы можете инициализировать полномочия двух следующим образом:

one:two:four:eight:sixteen:thirty_two:sixty_four:the_rest = iterate (*2) 1

Однако, как видно из ответа MkenViewMark на Haskell (который, кстати, заслуживает многих откровенных голосов) и других ответов, лучшего сжатия можно добиться, используя больше, чем просто +и -.


3

Clojure - 46 символов

(map print(butlast(rest(str'(Hello World!)))))

Обратите внимание, что Helloи World!являются символами, а не литералами любого рода.


3

C ++

/*
Hello World!
*/
#define CodeGolf(r) #r
#include<iostream>
using namespace std;
int main()
{
    char str[*"O"];
    freopen(__FILE__,CodeGolf(r),stdin);
    gets(str);gets(str);puts(str);
}

1
100Нарушает правило о числах. Пожалуйста, замените его чем-нибудь более забавным.
Джои Адамс

@ joey-adams Спасибо за указание. Поменял это.
fR0DDY

Line 7: error: ISO C++ forbids declaration of 'main' with no type
Натан Осман

@ Джордж-Эдисон Исправлено. Хотя он работал без intна g ++
fR0DDY

3

PHP - 49 символов

<?=Hello.chr(($a=-~-~-~0).~-$a).World.chr($a.$a);

Журнал изменений :

  • (73 -> 86) Забыл вывести восклицательный знак ... вздох
  • (86 -> 57) Использует одну переменную с приращением
  • (57 -> 51) Изменено использование битовых операторов на 0
  • (51 -> 49) Более побитовые операторы

1
Я уверен, что константы будут считаться строковыми литералами из-за преобразований.
Кевин Браун

@ Bass5098 Спасибо за ваши изменения! Я одобрил это.
nyuszika7h

@ Bass5098, который не работает, вам нужно иметь символы 32 и 33, а не 21 и 22. <?$a=-~-~-~0;echo Hello.chr($a.$a-1).World.chr($a.$a);работает, но это 54 символа.
zzzzBov

@zzzzBov Я не мог понять, как очистить редактирование первоначально, и забыл откатить его, как только он был одобрен.
Кевин Браун

Ой, я оставил 1там. Там я нарушаю свои собственные правила ... <?$a=-~-~-~0;echo Hello,chr($a.~-$a),World,chr($a.$a);это то, что я должен был использовать, все еще 54 символа.
zzzzBov

3

Python, 106

o=-~-~-~0
L=o+o
d,W=-~L,o**o
_=o*W
print str().join(chr(L+W+_-i)for i in[d*L,L+d,L,L,o,-~_,W,o,0,L,d+d,_])

Используйте '' (без предшествующего пробела) вместо str ()
aditsu

2
Также ОЧЕНЬ приятно! :) Кстати, множественное назначение не сохраняет никаких символов
aditsu

@aditsu: я не могу, это был бы строковый литерал. Спасибо за ваши комментарии. :)
flornquake

Ой, каким-то образом пустая строка не была
записана

3

Perl, 186 байт

@A=(0,0,0,0);@B=(@A,@A);@C=(@B,@B);@D=(@C,@C);@E=(@D,@D);@d=(@E,@D,@A);$l=[@d,@B];$o=[@$l,0,0,0];print(chr@$_)for[@E,@B],[@d,0],$l,$l,$o,\@D,[@E,@C,@A,0,0,0],$o,[@$o,0,0,0],$l,\@d,[@D,0]

Каждый символ печатается через его порядковый номер, который является длиной массива. Построение массивов оптимизируется через двоичное представление чисел символов.

Ungolfed:

@A = (0, 0, 0, 0);          # A = 2^2
@B = (@A, @A);              # B = 2^3
@C = (@B, @B);              # C = 2^4
@D = (@C, @C);              # D = 2^5
@E = (@D, @D);              # E = 2^6

# d = 100 = 0x64 = 1100100b
@d = (@E, @D, @A);          # d = 2^6 + 2^5 + 2^2 

# l = 108 = 0x6C = 1101100b
$l = [@d, @B];              # l = d + 2^3

# o = 111 = 0x6F = 1101111b
$o = [@$l, 0, 0, 0];        # o = l + 3

print (chr @$_) for
    [@E, @B],              # "H"    H  =  72 = 0x48 = 1001000b = 2^6 + 2^3
    [@d, 0],               # "e"    e  = 101 = 0x65 = 1100101b = d + 1  
    $l, $l, $o,            # "llo"
    \@D,                   # " "   ' ' =  32 = 0x20 = 0100000b = 2^5
    [@E, @C, @A, 0, 0, 0], # "W"    W  =  87 = 0x57 = 1010111b = 2^6 + 2^4 + 2^2 + 3
    $o,                    # "o"
    [@$o, 0, 0, 0],        # "r"    r  = 114 = 0x72 = 1110010b = o + 3
    $l, \@d,               # "ld"
    [@D,0]                 # "!"    !  =  33 = 0x21 = 0100001b = 2^5 + 1

кажется, что мое двоичное vodoo вдохновило вас :) +1
masterX244

3

Perl 6 , 199 байт

my \O=+[0];my \t=O+O;my \T=t+O;my \f=(t+t,O);my \F=t+T;my \S=T+T;my \L=(S,F);
say [~] ((S,T),(|L,t,0),(my \l=(|L,T,t)),l,(my \o=(|l,O,0)),F,(S,|f,t,0),o,(|L,|f),l,(|L,t),(F,0),)
.map({chr [+] t X**@_})

(новые строки добавляются для уменьшения ширины, но не нужны, поэтому не учитываются)


Hello World! закодирован как список списков степеней 2 каждой буквы.

Есть только одно место, где у меня есть литерал, 0который используется для чего-то другого, кроме 0. Он используется для создания одноэлементного списка, который сразу превращается в число 1с помощью оператора числового префикса ( +[0]).

my \O=+[0];    # one          # (List.elems)
my \t=O+O;     # two
my \T=t+O;     # Three
my \f=(t+t,O); # (four, one)  # <W r>
my \F=t+T;     # five
my \S=T+T;     # six

my \L=(S,F);   # lowercase letter  # (6,5)

say [~] (
  (S,T),            # H
  (|L,t,0),         # e
  (my \l=(|L,T,t)), # l
  l,                # l  reuse <l>
  (my \o=(|l,O,0)), # o  reuse <l>, add 0,1
  F,                # ␠
  (S,|f,t,0),       # W
  o,                # o  reuse <o>
  (|L,|f),          # r
  l,                # l  reuse <l>
  (|L,t),           # d
  (F,0),            # !
).map({chr [+] t X**@_})

3

JavaScript 662 символа

O=[[,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[],[,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]];for(O_O=[].length;O.length>O_O;O_O++)document.write(String.fromCharCode((O[O_O].length||-Math.pow([,,].length,[,,,,,].length)-[,,,,,,,].length)+Math.pow([,,].length,[,,,,,,].length)+Math.pow(++[,].length,[,,,].length)-[,].length));document.write(String.fromCharCode(Math.pow([,,].length,[,,,,,].length)+[,].length))

Как насчет злоупотребления литералами массива только для того, чтобы иметь одинарную базу. Эта программа имеет преимущество не использовать 0.


Несмотря на то, что это может быть допустимо, эта конкретная головоломка представляет собой кодовый гольф, что означает, что вы должны стремиться к максимально короткому коду. При 600+ символов вы не приблизитесь к <100 символам, которые уже есть в существующих решениях JS.
zzzzBov

1
@zzzzBov: На самом деле я не пытаюсь победить.
Конрад Боровски

1
Эта программа имеет преимущество не использовать 0. Как насчет O_O=0;?
Эрик Outgolfer

@EriktheGolfer: исправлено, спасибо. Я не заметил этого.
Конрад Боровски,

O_O=[].lengthможно записать как O_O=falseуменьшившую его на 4.
Atmocreations
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.