結果
| 問題 |
No.1298 OR XOR
|
| コンテスト | |
| ユーザー |
👑  terry_u16
|
| 提出日時 | 2020-11-27 21:28:00 |
| 言語 | C#(csc) (csc 3.9.0) |
| 結果 |
RE
|
| 実行時間 | - |
| コード長 | 14,235 bytes |
| コンパイル時間 | 2,739 ms |
| コンパイル使用メモリ | 113,536 KB |
| 実行使用メモリ | 17,280 KB |
| 最終ジャッジ日時 | 2024-07-23 22:04:54 |
| 合計ジャッジ時間 | 3,954 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge1 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | RE * 1 |
| other | RE * 13 |
コンパイルメッセージ
Microsoft (R) Visual C# Compiler version 3.9.0-6.21124.20 (db94f4cc) Copyright (C) Microsoft Corporation. All rights reserved.
ソースコード
using System;
using System.Buffers;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using YukicoderContest276.Questions;
namespace YukicoderContest276.Questions
{
public class QuestionA : AtCoderQuestionBase
{
public override void Solve(IOManager io)
{
var n = io.ReadInt();
var popcount = PopCount(n);
if (popcount <= 1)
{
io.WriteLine("-1 -1 -1");
}
else
{
var a = 0;
for (int i = 0; true; i++)
{
if (((n >> i) & 1) > 0)
{
a = 1 << i;
break;
}
}
var b = n ^ a;
var c = n;
io.WriteLine($"{a} {b} {c}");
}
}
int PopCount(int n)
{
var count = 0;
while (n > 0)
{
if ((n & 1) > 0)
{
count++;
}
n >>= 1;
}
return count;
}
}
}
namespace YukicoderContest276
{
class Program
{
static void Main(string[] args)
{
IAtCoderQuestion question = new QuestionA();
using var io = new IOManager(Console.OpenStandardInput(), Console.OpenStandardOutput());
question.Solve(io);
}
}
}
#region Base Class
namespace YukicoderContest276.Questions
{
public interface IAtCoderQuestion
{
string Solve(string input);
void Solve(IOManager io);
}
public abstract class AtCoderQuestionBase : IAtCoderQuestion
{
public string Solve(string input)
{
var inputStream = new MemoryStream(Encoding.UTF8.GetBytes(input));
var outputStream = new MemoryStream();
using var manager = new IOManager(inputStream, outputStream);
Solve(manager);
manager.Flush();
outputStream.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(outputStream);
return reader.ReadToEnd();
}
public abstract void Solve(IOManager io);
}
}
#endregion
#region Utils
namespace YukicoderContest276
{
public class IOManager : IDisposable
{
private readonly BinaryReader _reader;
private readonly StreamWriter _writer;
private bool _disposedValue;
private byte[] _buffer = new byte[1024];
private int _length;
private int _cursor;
private bool _eof;
const char ValidFirstChar = '!';
const char ValidLastChar = '~';
public IOManager(Stream input, Stream output)
{
_reader = new BinaryReader(input);
_writer = new StreamWriter(output) { AutoFlush = false };
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private char ReadAscii()
{
if (_cursor == _length)
{
_cursor = 0;
_length = _reader.Read(_buffer);
if (_length == 0)
{
if (!_eof)
{
_eof = true;
return char.MinValue;
}
else
{
ThrowEndOfStreamException();
}
}
}
return (char)_buffer[_cursor++];
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public char ReadChar()
{
char c;
while (!IsValidChar(c = ReadAscii())) { }
return c;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadString()
{
var builder = new StringBuilder();
char c;
while (!IsValidChar(c = ReadAscii())) { }
do
{
builder.Append(c);
} while (IsValidChar(c = ReadAscii()));
return builder.ToString();
}
public int ReadInt() => (int)ReadLong();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public long ReadLong()
{
long result = 0;
bool isPositive = true;
char c;
while (!IsNumericChar(c = ReadAscii())) { }
if (c == '-')
{
isPositive = false;
c = ReadAscii();
}
do
{
result *= 10;
result += c - '0';
} while (IsNumericChar(c = ReadAscii()));
return isPositive ? result : -result;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private Span<char> ReadChunk(Span<char> span)
{
var i = 0;
char c;
while (!IsValidChar(c = ReadAscii())) { }
do
{
span[i++] = c;
} while (IsValidChar(c = ReadAscii()));
return span.Slice(0, i);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double ReadDouble() => double.Parse(ReadChunk(stackalloc char[32]));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public decimal ReadDecimal() => decimal.Parse(ReadChunk(stackalloc char[32]));
public int[] ReadIntArray(int n)
{
var a = new int[n];
for (int i = 0; i < a.Length; i++)
{
a[i] = ReadInt();
}
return a;
}
public long[] ReadLongArray(int n)
{
var a = new long[n];
for (int i = 0; i < a.Length; i++)
{
a[i] = ReadLong();
}
return a;
}
public double[] ReadDoubleArray(int n)
{
var a = new double[n];
for (int i = 0; i < a.Length; i++)
{
a[i] = ReadDouble();
}
return a;
}
public decimal[] ReadDecimalArray(int n)
{
var a = new decimal[n];
for (int i = 0; i < a.Length; i++)
{
a[i] = ReadDecimal();
}
return a;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write<T>(T value) => _writer.Write(value.ToString());
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteLine<T>(T value) => _writer.WriteLine(value.ToString());
public void WriteLine<T>(IEnumerable<T> values, char separator)
{
var e = values.GetEnumerator();
if (e.MoveNext())
{
_writer.Write(e.Current.ToString());
while (e.MoveNext())
{
_writer.Write(separator);
_writer.Write(e.Current.ToString());
}
}
_writer.WriteLine();
}
public void WriteLine<T>(T[] values, char separator) => WriteLine((ReadOnlySpan<T>)values, separator);
public void WriteLine<T>(Span<T> values, char separator) => WriteLine((ReadOnlySpan<T>)values, separator);
public void WriteLine<T>(ReadOnlySpan<T> values, char separator)
{
for (int i = 0; i < values.Length - 1; i++)
{
_writer.Write(values[i]);
_writer.Write(separator);
}
if (values.Length > 0)
{
_writer.Write(values[^1]);
}
_writer.WriteLine();
}
public void Flush() => _writer.Flush();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool IsValidChar(char c) => ValidFirstChar <= c && c <= ValidLastChar;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool IsNumericChar(char c) => ('0' <= c && c <= '9') || c == '-';
private void ThrowEndOfStreamException() => throw new EndOfStreamException();
protected virtual void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing)
{
_reader.Dispose();
_writer.Flush();
_writer.Dispose();
}
_disposedValue = true;
}
}
public void Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}
public static class UtilExtensions
{
public static bool ChangeMax<T>(ref this T value, T other) where T : struct, IComparable<T>
{
if (value.CompareTo(other) < 0)
{
value = other;
return true;
}
return false;
}
public static bool ChangeMin<T>(ref this T value, T other) where T : struct, IComparable<T>
{
if (value.CompareTo(other) > 0)
{
value = other;
return true;
}
return false;
}
public static void SwapIfLargerThan<T>(ref this T a, ref T b) where T : struct, IComparable<T>
{
if (a.CompareTo(b) > 0)
{
(a, b) = (b, a);
}
}
public static void SwapIfSmallerThan<T>(ref this T a, ref T b) where T : struct, IComparable<T>
{
if (a.CompareTo(b) < 0)
{
(a, b) = (b, a);
}
}
public static void Sort<T>(this T[] array) where T : IComparable<T> => Array.Sort(array);
public static void Sort<T>(this T[] array, Comparison<T> comparison) => Array.Sort(array, comparison);
}
public static class CollectionExtensions
{
public static void Fill<T>(this T[] array, T value) => array.AsSpan().Fill(value);
public static void Fill<T>(this T[,] array, T value) => MemoryMarshal.CreateSpan(ref array[0, 0], array.Length).Fill(value);
public static void Fill<T>(this T[,,] array, T value) => MemoryMarshal.CreateSpan(ref array[0, 0, 0], array.Length).Fill(value);
public static void Fill<T>(this T[,,,] array, T value) => MemoryMarshal.CreateSpan(ref array[0, 0, 0, 0], array.Length).Fill(value);
}
public static class SearchExtensions
{
struct LowerBoundComparer<T> : IComparer<T> where T : IComparable<T>
{
public int Compare(T x, T y) => 0 <= x.CompareTo(y) ? 1 : -1;
}
struct UpperBoundComparer<T> : IComparer<T> where T : IComparable<T>
{
public int Compare(T x, T y) => 0 < x.CompareTo(y) ? 1 : -1;
}
// https://trsing.hatenablog.com/entry/2019/08/27/211038
public static int GetGreaterEqualIndex<T>(this ReadOnlySpan<T> span, T inclusiveMin) where T : IComparable<T> => ~span.BinarySearch(inclusiveMin, new UpperBoundComparer<T>());
public static int GetGreaterThanIndex<T>(this ReadOnlySpan<T> span, T exclusiveMin) where T : IComparable<T> => ~span.BinarySearch(exclusiveMin, new LowerBoundComparer<T>());
public static int GetLessEqualIndex<T>(this ReadOnlySpan<T> span, T inclusiveMax) where T : IComparable<T> => ~span.BinarySearch(inclusiveMax, new LowerBoundComparer<T>()) - 1;
public static int GetLessThanIndex<T>(this ReadOnlySpan<T> span, T exclusiveMax) where T : IComparable<T> => ~span.BinarySearch(exclusiveMax, new UpperBoundComparer<T>()) - 1;
public static int GetGreaterEqualIndex<T>(this Span<T> span, T inclusiveMin) where T : IComparable<T> => ((ReadOnlySpan<T>)span).GetGreaterEqualIndex(inclusiveMin);
public static int GetGreaterThanIndex<T>(this Span<T> span, T exclusiveMin) where T : IComparable<T> => ((ReadOnlySpan<T>)span).GetGreaterThanIndex(exclusiveMin);
public static int GetLessEqualIndex<T>(this Span<T> span, T inclusiveMax) where T : IComparable<T> => ((ReadOnlySpan<T>)span).GetLessEqualIndex(inclusiveMax);
public static int GetLessThanIndex<T>(this Span<T> span, T exclusiveMax) where T : IComparable<T> => ((ReadOnlySpan<T>)span).GetLessThanIndex(exclusiveMax);
public static int BoundaryBinarySearch(Predicate<int> predicate, int ok, int ng)
{
while (Math.Abs(ok - ng) > 1)
{
int mid = (ok + ng) / 2;
if (predicate(mid))
{
ok = mid;
}
else
{
ng = mid;
}
}
return ok;
}
public static long BoundaryBinarySearch(Predicate<long> predicate, long ok, long ng)
{
while (Math.Abs(ok - ng) > 1)
{
long mid = (ok + ng) / 2;
if (predicate(mid))
{
ok = mid;
}
else
{
ng = mid;
}
}
return ok;
}
public static double Bisection(Func<double, double> f, double a, double b, double eps = 1e-9)
{
if (f(a) * f(b) >= 0)
{
throw new ArgumentException("f(a)とf(b)は異符号である必要があります。");
}
const int maxLoop = 100;
double mid = (a + b) / 2;
for (int i = 0; i < maxLoop; i++)
{
if (f(a) * f(mid) < 0)
{
b = mid;
}
else
{
a = mid;
}
mid = (a + b) / 2;
if (Math.Abs(b - a) < eps)
{
break;
}
}
return mid;
}
}
}
#endregion